try
{
    if (Convert) 
	    Convert = {};
}
catch(ex)
{
    Convert = {};
}
	

Convert.IsErrorEventHandler = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is ErrorEventHandler</param>
    return CheckConvertIs(",ErrorEventHandler,", javascriptObject, true);
}

Convert.ToErrorEventHandler = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to ErrorEventHandler</param>
    /// <returns type="ErrorEventHandler" />
    if (!Convert.IsErrorEventHandler(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new ErrorEventHandler(javascriptObject.element)
        else
            return new ErrorEventHandler(javascriptObject);
    }
}


Convert.IsParserErrorEventHandler = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is ParserErrorEventHandler</param>
    return CheckConvertIs(",ParserErrorEventHandler,", javascriptObject, true);
}

Convert.ToParserErrorEventHandler = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to ParserErrorEventHandler</param>
    /// <returns type="ParserErrorEventHandler" />
    if (!Convert.IsParserErrorEventHandler(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new ParserErrorEventHandler(javascriptObject.element)
        else
            return new ParserErrorEventHandler(javascriptObject);
    }
}


Convert.IsRuntimeErrorEventHandler = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is RuntimeErrorEventHandler</param>
    return CheckConvertIs(",RuntimeErrorEventHandler,", javascriptObject, true);
}

Convert.ToRuntimeErrorEventHandler = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to RuntimeErrorEventHandler</param>
    /// <returns type="RuntimeErrorEventHandler" />
    if (!Convert.IsRuntimeErrorEventHandler(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new RuntimeErrorEventHandler(javascriptObject.element)
        else
            return new RuntimeErrorEventHandler(javascriptObject);
    }
}


Convert.IsTextWrapping = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is TextWrapping</param>
    return CheckConvertIs(",TextWrapping,", javascriptObject, true);
}

Convert.ToTextWrapping = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to TextWrapping</param>
    /// <returns type="TextWrapping" />
    if (!Convert.IsTextWrapping(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new TextWrapping(javascriptObject.element)
        else
            return new TextWrapping(javascriptObject);
    }
}


Convert.IsFontWeights = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is FontWeights</param>
    return CheckConvertIs(",FontWeights,", javascriptObject, true);
}

Convert.ToFontWeights = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to FontWeights</param>
    /// <returns type="FontWeights" />
    if (!Convert.IsFontWeights(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new FontWeights(javascriptObject.element)
        else
            return new FontWeights(javascriptObject);
    }
}


Convert.IsFontStyles = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is FontStyles</param>
    return CheckConvertIs(",FontStyles,", javascriptObject, true);
}

Convert.ToFontStyles = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to FontStyles</param>
    /// <returns type="FontStyles" />
    if (!Convert.IsFontStyles(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new FontStyles(javascriptObject.element)
        else
            return new FontStyles(javascriptObject);
    }
}


Convert.IsStyleSimulations = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is StyleSimulations</param>
    return CheckConvertIs(",StyleSimulations,", javascriptObject, true);
}

Convert.ToStyleSimulations = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to StyleSimulations</param>
    /// <returns type="StyleSimulations" />
    if (!Convert.IsStyleSimulations(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new StyleSimulations(javascriptObject.element)
        else
            return new StyleSimulations(javascriptObject);
    }
}


Convert.IsTextDecorations = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is TextDecorations</param>
    return CheckConvertIs(",TextDecorations,", javascriptObject, true);
}

Convert.ToTextDecorations = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to TextDecorations</param>
    /// <returns type="TextDecorations" />
    if (!Convert.IsTextDecorations(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new TextDecorations(javascriptObject.element)
        else
            return new TextDecorations(javascriptObject);
    }
}


Convert.IsFontStretches = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is FontStretches</param>
    return CheckConvertIs(",FontStretches,", javascriptObject, true);
}

Convert.ToFontStretches = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to FontStretches</param>
    /// <returns type="FontStretches" />
    if (!Convert.IsFontStretches(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new FontStretches(javascriptObject.element)
        else
            return new FontStretches(javascriptObject);
    }
}


Convert.IsVisibility = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Visibility</param>
    return CheckConvertIs(",Visibility,", javascriptObject, true);
}

Convert.ToVisibility = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Visibility</param>
    /// <returns type="Visibility" />
    if (!Convert.IsVisibility(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Visibility(javascriptObject.element)
        else
            return new Visibility(javascriptObject);
    }
}


Convert.IsErrorType = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is ErrorType</param>
    return CheckConvertIs(",ErrorType,", javascriptObject, true);
}

Convert.ToErrorType = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to ErrorType</param>
    /// <returns type="ErrorType" />
    if (!Convert.IsErrorType(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new ErrorType(javascriptObject.element)
        else
            return new ErrorType(javascriptObject);
    }
}


Convert.IsDependencyObject = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is DependencyObject</param>
    return CheckConvertIs(",DependencyObject,Visual,UIElement,FrameworkElement,Collection,Inlines,TriggerCollection,EventTrigger,TriggerActionCollection,Downloader,ResourceDictionary,Stroke,StrokeCollection,DrawingAttributes,Transform,PathSegment,Brush,TileBrush,Geometry,RotateTransform,ScaleTransform,SkewTransform,TranslateTransform,TransformCollection,TransformGroup,MatrixTransform,LineSegment,BezierSegment,QuadraticBezierSegment,ArcSegment,PolyLineSegment,PolyBezierSegment,PolyQuadraticBezierSegment,PathSegmentCollection,PathFigure,PathFigureCollection,PathGeometry,EllipseGeometry,RectangleGeometry,LineGeometry,GeometryCollection,GeometryGroup,SolidColorBrush,GradientStop,GradientStopCollection,GradientBrush,LinearGradientBrush,RadialGradientBrush,ImageBrush,VideoBrush,VisualCollection,TimelineCollection,MediaAttribute,MediaAttributeCollection,Timeline,TimelineGroup,ParallelTimeline,BeginStoryboard,Storyboard,Animation,DoubleAnimation,ColorAnimation,PointAnimation,KeySpline,KeyFrame,ColorKeyFrameCollection,DoubleKeyFrameCollection,PointKeyFrameCollection,DoubleAnimationUsingKeyFrames,DoubleKeyFrame,DiscreteDoubleKeyFrame,LinearDoubleKeyFrame,SplineDoubleKeyFrame,ColorAnimationUsingKeyFrames,ColorKeyFrame,DiscreteColorKeyFrame,LinearColorKeyFrame,SplineColorKeyFrame,PointAnimationUsingKeyFrames,PointKeyFrame,DiscretePointKeyFrame,LinearPointKeyFrame,SplinePointKeyFrame,TimelineMarker,TimelineMarkerCollection,StylusPoint,StylusPointCollection,StylusInfo,Shape,Path,Ellipse,Line,Polygon,Polyline,Rectangle,Inline,Glyphs,Run,LineBreak,Panel,MediaBase,ImageSL,Canvas,TextBlock,MediaElement,InkPresenter,Control,", javascriptObject, false);
}

Convert.ToDependencyObject = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to DependencyObject</param>
    /// <returns type="DependencyObject" />
    if (!Convert.IsDependencyObject(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new DependencyObject(javascriptObject.element)
        else
            return new DependencyObject(javascriptObject);
    }
}


Convert.IsVisual = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Visual</param>
    return CheckConvertIs(",Visual,UIElement,FrameworkElement,Shape,Path,Ellipse,Line,Polygon,Polyline,Rectangle,Glyphs,Panel,MediaBase,ImageSL,Canvas,TextBlock,MediaElement,InkPresenter,Control,", javascriptObject, false);
}

Convert.ToVisual = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Visual</param>
    /// <returns type="Visual" />
    if (!Convert.IsVisual(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Visual(javascriptObject.element)
        else
            return new Visual(javascriptObject);
    }
}


Convert.IsUIElement = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is UIElement</param>
    return CheckConvertIs(",UIElement,FrameworkElement,Shape,Path,Ellipse,Line,Polygon,Polyline,Rectangle,Glyphs,Panel,MediaBase,ImageSL,Canvas,TextBlock,MediaElement,InkPresenter,Control,", javascriptObject, false);
}

Convert.ToUIElement = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to UIElement</param>
    /// <returns type="UIElement" />
    if (!Convert.IsUIElement(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new UIElement(javascriptObject.element)
        else
            return new UIElement(javascriptObject);
    }
}


Convert.IsFrameworkElement = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is FrameworkElement</param>
    return CheckConvertIs(",FrameworkElement,Shape,Path,Ellipse,Line,Polygon,Polyline,Rectangle,Glyphs,Panel,MediaBase,ImageSL,Canvas,TextBlock,MediaElement,InkPresenter,Control,", javascriptObject, false);
}

Convert.ToFrameworkElement = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to FrameworkElement</param>
    /// <returns type="FrameworkElement" />
    if (!Convert.IsFrameworkElement(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new FrameworkElement(javascriptObject.element)
        else
            return new FrameworkElement(javascriptObject);
    }
}


Convert.IsCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Collection</param>
    return CheckConvertIs(",Collection,", javascriptObject, false);
}

Convert.ToCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Collection</param>
    /// <returns type="Collection" />
    if (!Convert.IsCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Collection(javascriptObject.element)
        else
            return new Collection(javascriptObject);
    }
}


Convert.IsInlines = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Inlines</param>
    return CheckConvertIs(",Inlines,", javascriptObject, false);
}

Convert.ToInlines = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Inlines</param>
    /// <returns type="Inlines" />
    if (!Convert.IsInlines(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Inlines(javascriptObject.element)
        else
            return new Inlines(javascriptObject);
    }
}


Convert.IsTriggerCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is TriggerCollection</param>
    return CheckConvertIs(",TriggerCollection,", javascriptObject, false);
}

Convert.ToTriggerCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to TriggerCollection</param>
    /// <returns type="TriggerCollection" />
    if (!Convert.IsTriggerCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new TriggerCollection(javascriptObject.element)
        else
            return new TriggerCollection(javascriptObject);
    }
}


Convert.IsEventTrigger = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is EventTrigger</param>
    return CheckConvertIs(",EventTrigger,", javascriptObject, false);
}

Convert.ToEventTrigger = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to EventTrigger</param>
    /// <returns type="EventTrigger" />
    if (!Convert.IsEventTrigger(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new EventTrigger(javascriptObject.element)
        else
            return new EventTrigger(javascriptObject);
    }
}


Convert.IsTriggerActionCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is TriggerActionCollection</param>
    return CheckConvertIs(",TriggerActionCollection,", javascriptObject, false);
}

Convert.ToTriggerActionCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to TriggerActionCollection</param>
    /// <returns type="TriggerActionCollection" />
    if (!Convert.IsTriggerActionCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new TriggerActionCollection(javascriptObject.element)
        else
            return new TriggerActionCollection(javascriptObject);
    }
}


Convert.IsErrorEventArgs = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is ErrorEventArgs</param>
    return CheckConvertIs(",ErrorEventArgs,ParserErrorEventArgs,RuntimeErrorEventArgs,", javascriptObject, true);
}

Convert.ToErrorEventArgs = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to ErrorEventArgs</param>
    /// <returns type="ErrorEventArgs" />
    if (!Convert.IsErrorEventArgs(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new ErrorEventArgs(javascriptObject.element)
        else
            return new ErrorEventArgs(javascriptObject);
    }
}


Convert.IsParserErrorEventArgs = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is ParserErrorEventArgs</param>
    return CheckConvertIs(",ParserErrorEventArgs,", javascriptObject, true);
}

Convert.ToParserErrorEventArgs = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to ParserErrorEventArgs</param>
    /// <returns type="ParserErrorEventArgs" />
    if (!Convert.IsParserErrorEventArgs(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new ParserErrorEventArgs(javascriptObject.element)
        else
            return new ParserErrorEventArgs(javascriptObject);
    }
}


Convert.IsRuntimeErrorEventArgs = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is RuntimeErrorEventArgs</param>
    return CheckConvertIs(",RuntimeErrorEventArgs,", javascriptObject, true);
}

Convert.ToRuntimeErrorEventArgs = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to RuntimeErrorEventArgs</param>
    /// <returns type="RuntimeErrorEventArgs" />
    if (!Convert.IsRuntimeErrorEventArgs(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new RuntimeErrorEventArgs(javascriptObject.element)
        else
            return new RuntimeErrorEventArgs(javascriptObject);
    }
}


Convert.IsDownloader = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Downloader</param>
    return CheckConvertIs(",Downloader,", javascriptObject, false);
}

Convert.ToDownloader = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Downloader</param>
    /// <returns type="Downloader" />
    if (!Convert.IsDownloader(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Downloader(javascriptObject.element)
        else
            return new Downloader(javascriptObject);
    }
}


Convert.IsResourceDictionary = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is ResourceDictionary</param>
    return CheckConvertIs(",ResourceDictionary,", javascriptObject, false);
}

Convert.ToResourceDictionary = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to ResourceDictionary</param>
    /// <returns type="ResourceDictionary" />
    if (!Convert.IsResourceDictionary(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new ResourceDictionary(javascriptObject.element)
        else
            return new ResourceDictionary(javascriptObject);
    }
}


Convert.IsStroke = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Stroke</param>
    return CheckConvertIs(",Stroke,", javascriptObject, false);
}

Convert.ToStroke = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Stroke</param>
    /// <returns type="Stroke" />
    if (!Convert.IsStroke(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Stroke(javascriptObject.element)
        else
            return new Stroke(javascriptObject);
    }
}


Convert.IsStrokeCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is StrokeCollection</param>
    return CheckConvertIs(",StrokeCollection,", javascriptObject, false);
}

Convert.ToStrokeCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to StrokeCollection</param>
    /// <returns type="StrokeCollection" />
    if (!Convert.IsStrokeCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new StrokeCollection(javascriptObject.element)
        else
            return new StrokeCollection(javascriptObject);
    }
}


Convert.IsDrawingAttributes = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is DrawingAttributes</param>
    return CheckConvertIs(",DrawingAttributes,", javascriptObject, false);
}

Convert.ToDrawingAttributes = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to DrawingAttributes</param>
    /// <returns type="DrawingAttributes" />
    if (!Convert.IsDrawingAttributes(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new DrawingAttributes(javascriptObject.element)
        else
            return new DrawingAttributes(javascriptObject);
    }
}


Convert.IsFillRule = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is FillRule</param>
    return CheckConvertIs(",FillRule,", javascriptObject, true);
}

Convert.ToFillRule = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to FillRule</param>
    /// <returns type="FillRule" />
    if (!Convert.IsFillRule(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new FillRule(javascriptObject.element)
        else
            return new FillRule(javascriptObject);
    }
}


Convert.IsSweepDirection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is SweepDirection</param>
    return CheckConvertIs(",SweepDirection,", javascriptObject, true);
}

Convert.ToSweepDirection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to SweepDirection</param>
    /// <returns type="SweepDirection" />
    if (!Convert.IsSweepDirection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new SweepDirection(javascriptObject.element)
        else
            return new SweepDirection(javascriptObject);
    }
}


Convert.IsGradientSpreadMethod = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is GradientSpreadMethod</param>
    return CheckConvertIs(",GradientSpreadMethod,", javascriptObject, true);
}

Convert.ToGradientSpreadMethod = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to GradientSpreadMethod</param>
    /// <returns type="GradientSpreadMethod" />
    if (!Convert.IsGradientSpreadMethod(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new GradientSpreadMethod(javascriptObject.element)
        else
            return new GradientSpreadMethod(javascriptObject);
    }
}


Convert.IsColorInterpolationMode = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is ColorInterpolationMode</param>
    return CheckConvertIs(",ColorInterpolationMode,", javascriptObject, true);
}

Convert.ToColorInterpolationMode = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to ColorInterpolationMode</param>
    /// <returns type="ColorInterpolationMode" />
    if (!Convert.IsColorInterpolationMode(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new ColorInterpolationMode(javascriptObject.element)
        else
            return new ColorInterpolationMode(javascriptObject);
    }
}


Convert.IsBrushMappingMode = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is BrushMappingMode</param>
    return CheckConvertIs(",BrushMappingMode,", javascriptObject, true);
}

Convert.ToBrushMappingMode = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to BrushMappingMode</param>
    /// <returns type="BrushMappingMode" />
    if (!Convert.IsBrushMappingMode(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new BrushMappingMode(javascriptObject.element)
        else
            return new BrushMappingMode(javascriptObject);
    }
}


Convert.IsAlignmentX = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is AlignmentX</param>
    return CheckConvertIs(",AlignmentX,", javascriptObject, true);
}

Convert.ToAlignmentX = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to AlignmentX</param>
    /// <returns type="AlignmentX" />
    if (!Convert.IsAlignmentX(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new AlignmentX(javascriptObject.element)
        else
            return new AlignmentX(javascriptObject);
    }
}


Convert.IsAlignmentY = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is AlignmentY</param>
    return CheckConvertIs(",AlignmentY,", javascriptObject, true);
}

Convert.ToAlignmentY = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to AlignmentY</param>
    /// <returns type="AlignmentY" />
    if (!Convert.IsAlignmentY(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new AlignmentY(javascriptObject.element)
        else
            return new AlignmentY(javascriptObject);
    }
}


Convert.IsStretch = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Stretch</param>
    return CheckConvertIs(",Stretch,", javascriptObject, true);
}

Convert.ToStretch = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Stretch</param>
    /// <returns type="Stretch" />
    if (!Convert.IsStretch(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Stretch(javascriptObject.element)
        else
            return new Stretch(javascriptObject);
    }
}


Convert.IsPenLineCap = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is PenLineCap</param>
    return CheckConvertIs(",PenLineCap,", javascriptObject, true);
}

Convert.ToPenLineCap = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to PenLineCap</param>
    /// <returns type="PenLineCap" />
    if (!Convert.IsPenLineCap(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new PenLineCap(javascriptObject.element)
        else
            return new PenLineCap(javascriptObject);
    }
}


Convert.IsPenLineJoin = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is PenLineJoin</param>
    return CheckConvertIs(",PenLineJoin,", javascriptObject, true);
}

Convert.ToPenLineJoin = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to PenLineJoin</param>
    /// <returns type="PenLineJoin" />
    if (!Convert.IsPenLineJoin(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new PenLineJoin(javascriptObject.element)
        else
            return new PenLineJoin(javascriptObject);
    }
}


Convert.IsTransform = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Transform</param>
    return CheckConvertIs(",Transform,RotateTransform,ScaleTransform,SkewTransform,TranslateTransform,TransformGroup,MatrixTransform,", javascriptObject, false);
}

Convert.ToTransform = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Transform</param>
    /// <returns type="Transform" />
    if (!Convert.IsTransform(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Transform(javascriptObject.element)
        else
            return new Transform(javascriptObject);
    }
}


Convert.IsPathSegment = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is PathSegment</param>
    return CheckConvertIs(",PathSegment,LineSegment,BezierSegment,QuadraticBezierSegment,ArcSegment,PolyLineSegment,PolyBezierSegment,PolyQuadraticBezierSegment,", javascriptObject, false);
}

Convert.ToPathSegment = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to PathSegment</param>
    /// <returns type="PathSegment" />
    if (!Convert.IsPathSegment(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new PathSegment(javascriptObject.element)
        else
            return new PathSegment(javascriptObject);
    }
}


Convert.IsBrush = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Brush</param>
    return CheckConvertIs(",Brush,TileBrush,SolidColorBrush,GradientBrush,LinearGradientBrush,RadialGradientBrush,ImageBrush,VideoBrush,", javascriptObject, false);
}

Convert.ToBrush = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Brush</param>
    /// <returns type="Brush" />
    if (!Convert.IsBrush(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Brush(javascriptObject.element)
        else
            return new Brush(javascriptObject);
    }
}


Convert.IsTileBrush = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is TileBrush</param>
    return CheckConvertIs(",TileBrush,ImageBrush,VideoBrush,", javascriptObject, false);
}

Convert.ToTileBrush = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to TileBrush</param>
    /// <returns type="TileBrush" />
    if (!Convert.IsTileBrush(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new TileBrush(javascriptObject.element)
        else
            return new TileBrush(javascriptObject);
    }
}


Convert.IsGeometry = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Geometry</param>
    return CheckConvertIs(",Geometry,PathGeometry,EllipseGeometry,RectangleGeometry,LineGeometry,GeometryGroup,", javascriptObject, false);
}

Convert.ToGeometry = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Geometry</param>
    /// <returns type="Geometry" />
    if (!Convert.IsGeometry(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Geometry(javascriptObject.element)
        else
            return new Geometry(javascriptObject);
    }
}


Convert.IsRotateTransform = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is RotateTransform</param>
    return CheckConvertIs(",RotateTransform,", javascriptObject, false);
}

Convert.ToRotateTransform = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to RotateTransform</param>
    /// <returns type="RotateTransform" />
    if (!Convert.IsRotateTransform(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new RotateTransform(javascriptObject.element)
        else
            return new RotateTransform(javascriptObject);
    }
}


Convert.IsScaleTransform = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is ScaleTransform</param>
    return CheckConvertIs(",ScaleTransform,", javascriptObject, false);
}

Convert.ToScaleTransform = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to ScaleTransform</param>
    /// <returns type="ScaleTransform" />
    if (!Convert.IsScaleTransform(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new ScaleTransform(javascriptObject.element)
        else
            return new ScaleTransform(javascriptObject);
    }
}


Convert.IsSkewTransform = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is SkewTransform</param>
    return CheckConvertIs(",SkewTransform,", javascriptObject, false);
}

Convert.ToSkewTransform = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to SkewTransform</param>
    /// <returns type="SkewTransform" />
    if (!Convert.IsSkewTransform(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new SkewTransform(javascriptObject.element)
        else
            return new SkewTransform(javascriptObject);
    }
}


Convert.IsTranslateTransform = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is TranslateTransform</param>
    return CheckConvertIs(",TranslateTransform,", javascriptObject, false);
}

Convert.ToTranslateTransform = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to TranslateTransform</param>
    /// <returns type="TranslateTransform" />
    if (!Convert.IsTranslateTransform(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new TranslateTransform(javascriptObject.element)
        else
            return new TranslateTransform(javascriptObject);
    }
}


Convert.IsTransformCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is TransformCollection</param>
    return CheckConvertIs(",TransformCollection,", javascriptObject, false);
}

Convert.ToTransformCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to TransformCollection</param>
    /// <returns type="TransformCollection" />
    if (!Convert.IsTransformCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new TransformCollection(javascriptObject.element)
        else
            return new TransformCollection(javascriptObject);
    }
}


Convert.IsTransformGroup = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is TransformGroup</param>
    return CheckConvertIs(",TransformGroup,", javascriptObject, false);
}

Convert.ToTransformGroup = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to TransformGroup</param>
    /// <returns type="TransformGroup" />
    if (!Convert.IsTransformGroup(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new TransformGroup(javascriptObject.element)
        else
            return new TransformGroup(javascriptObject);
    }
}


Convert.IsMatrixTransform = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is MatrixTransform</param>
    return CheckConvertIs(",MatrixTransform,", javascriptObject, false);
}

Convert.ToMatrixTransform = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to MatrixTransform</param>
    /// <returns type="MatrixTransform" />
    if (!Convert.IsMatrixTransform(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new MatrixTransform(javascriptObject.element)
        else
            return new MatrixTransform(javascriptObject);
    }
}


Convert.IsLineSegment = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is LineSegment</param>
    return CheckConvertIs(",LineSegment,", javascriptObject, false);
}

Convert.ToLineSegment = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to LineSegment</param>
    /// <returns type="LineSegment" />
    if (!Convert.IsLineSegment(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new LineSegment(javascriptObject.element)
        else
            return new LineSegment(javascriptObject);
    }
}


Convert.IsBezierSegment = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is BezierSegment</param>
    return CheckConvertIs(",BezierSegment,", javascriptObject, false);
}

Convert.ToBezierSegment = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to BezierSegment</param>
    /// <returns type="BezierSegment" />
    if (!Convert.IsBezierSegment(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new BezierSegment(javascriptObject.element)
        else
            return new BezierSegment(javascriptObject);
    }
}


Convert.IsQuadraticBezierSegment = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is QuadraticBezierSegment</param>
    return CheckConvertIs(",QuadraticBezierSegment,", javascriptObject, false);
}

Convert.ToQuadraticBezierSegment = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to QuadraticBezierSegment</param>
    /// <returns type="QuadraticBezierSegment" />
    if (!Convert.IsQuadraticBezierSegment(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new QuadraticBezierSegment(javascriptObject.element)
        else
            return new QuadraticBezierSegment(javascriptObject);
    }
}


Convert.IsArcSegment = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is ArcSegment</param>
    return CheckConvertIs(",ArcSegment,", javascriptObject, false);
}

Convert.ToArcSegment = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to ArcSegment</param>
    /// <returns type="ArcSegment" />
    if (!Convert.IsArcSegment(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new ArcSegment(javascriptObject.element)
        else
            return new ArcSegment(javascriptObject);
    }
}


Convert.IsPolyLineSegment = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is PolyLineSegment</param>
    return CheckConvertIs(",PolyLineSegment,", javascriptObject, false);
}

Convert.ToPolyLineSegment = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to PolyLineSegment</param>
    /// <returns type="PolyLineSegment" />
    if (!Convert.IsPolyLineSegment(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new PolyLineSegment(javascriptObject.element)
        else
            return new PolyLineSegment(javascriptObject);
    }
}


Convert.IsPolyBezierSegment = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is PolyBezierSegment</param>
    return CheckConvertIs(",PolyBezierSegment,", javascriptObject, false);
}

Convert.ToPolyBezierSegment = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to PolyBezierSegment</param>
    /// <returns type="PolyBezierSegment" />
    if (!Convert.IsPolyBezierSegment(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new PolyBezierSegment(javascriptObject.element)
        else
            return new PolyBezierSegment(javascriptObject);
    }
}


Convert.IsPolyQuadraticBezierSegment = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is PolyQuadraticBezierSegment</param>
    return CheckConvertIs(",PolyQuadraticBezierSegment,", javascriptObject, false);
}

Convert.ToPolyQuadraticBezierSegment = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to PolyQuadraticBezierSegment</param>
    /// <returns type="PolyQuadraticBezierSegment" />
    if (!Convert.IsPolyQuadraticBezierSegment(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new PolyQuadraticBezierSegment(javascriptObject.element)
        else
            return new PolyQuadraticBezierSegment(javascriptObject);
    }
}


Convert.IsPathSegmentCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is PathSegmentCollection</param>
    return CheckConvertIs(",PathSegmentCollection,", javascriptObject, false);
}

Convert.ToPathSegmentCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to PathSegmentCollection</param>
    /// <returns type="PathSegmentCollection" />
    if (!Convert.IsPathSegmentCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new PathSegmentCollection(javascriptObject.element)
        else
            return new PathSegmentCollection(javascriptObject);
    }
}


Convert.IsPathFigure = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is PathFigure</param>
    return CheckConvertIs(",PathFigure,", javascriptObject, false);
}

Convert.ToPathFigure = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to PathFigure</param>
    /// <returns type="PathFigure" />
    if (!Convert.IsPathFigure(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new PathFigure(javascriptObject.element)
        else
            return new PathFigure(javascriptObject);
    }
}


Convert.IsPathFigureCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is PathFigureCollection</param>
    return CheckConvertIs(",PathFigureCollection,", javascriptObject, false);
}

Convert.ToPathFigureCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to PathFigureCollection</param>
    /// <returns type="PathFigureCollection" />
    if (!Convert.IsPathFigureCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new PathFigureCollection(javascriptObject.element)
        else
            return new PathFigureCollection(javascriptObject);
    }
}


Convert.IsPathGeometry = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is PathGeometry</param>
    return CheckConvertIs(",PathGeometry,", javascriptObject, false);
}

Convert.ToPathGeometry = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to PathGeometry</param>
    /// <returns type="PathGeometry" />
    if (!Convert.IsPathGeometry(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new PathGeometry(javascriptObject.element)
        else
            return new PathGeometry(javascriptObject);
    }
}


Convert.IsEllipseGeometry = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is EllipseGeometry</param>
    return CheckConvertIs(",EllipseGeometry,", javascriptObject, false);
}

Convert.ToEllipseGeometry = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to EllipseGeometry</param>
    /// <returns type="EllipseGeometry" />
    if (!Convert.IsEllipseGeometry(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new EllipseGeometry(javascriptObject.element)
        else
            return new EllipseGeometry(javascriptObject);
    }
}


Convert.IsRectangleGeometry = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is RectangleGeometry</param>
    return CheckConvertIs(",RectangleGeometry,", javascriptObject, false);
}

Convert.ToRectangleGeometry = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to RectangleGeometry</param>
    /// <returns type="RectangleGeometry" />
    if (!Convert.IsRectangleGeometry(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new RectangleGeometry(javascriptObject.element)
        else
            return new RectangleGeometry(javascriptObject);
    }
}


Convert.IsLineGeometry = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is LineGeometry</param>
    return CheckConvertIs(",LineGeometry,", javascriptObject, false);
}

Convert.ToLineGeometry = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to LineGeometry</param>
    /// <returns type="LineGeometry" />
    if (!Convert.IsLineGeometry(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new LineGeometry(javascriptObject.element)
        else
            return new LineGeometry(javascriptObject);
    }
}


Convert.IsGeometryCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is GeometryCollection</param>
    return CheckConvertIs(",GeometryCollection,", javascriptObject, false);
}

Convert.ToGeometryCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to GeometryCollection</param>
    /// <returns type="GeometryCollection" />
    if (!Convert.IsGeometryCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new GeometryCollection(javascriptObject.element)
        else
            return new GeometryCollection(javascriptObject);
    }
}


Convert.IsGeometryGroup = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is GeometryGroup</param>
    return CheckConvertIs(",GeometryGroup,", javascriptObject, false);
}

Convert.ToGeometryGroup = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to GeometryGroup</param>
    /// <returns type="GeometryGroup" />
    if (!Convert.IsGeometryGroup(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new GeometryGroup(javascriptObject.element)
        else
            return new GeometryGroup(javascriptObject);
    }
}


Convert.IsSolidColorBrush = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is SolidColorBrush</param>
    return CheckConvertIs(",SolidColorBrush,", javascriptObject, false);
}

Convert.ToSolidColorBrush = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to SolidColorBrush</param>
    /// <returns type="SolidColorBrush" />
    if (!Convert.IsSolidColorBrush(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new SolidColorBrush(javascriptObject.element)
        else
            return new SolidColorBrush(javascriptObject);
    }
}


Convert.IsGradientStop = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is GradientStop</param>
    return CheckConvertIs(",GradientStop,", javascriptObject, false);
}

Convert.ToGradientStop = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to GradientStop</param>
    /// <returns type="GradientStop" />
    if (!Convert.IsGradientStop(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new GradientStop(javascriptObject.element)
        else
            return new GradientStop(javascriptObject);
    }
}


Convert.IsGradientStopCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is GradientStopCollection</param>
    return CheckConvertIs(",GradientStopCollection,", javascriptObject, false);
}

Convert.ToGradientStopCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to GradientStopCollection</param>
    /// <returns type="GradientStopCollection" />
    if (!Convert.IsGradientStopCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new GradientStopCollection(javascriptObject.element)
        else
            return new GradientStopCollection(javascriptObject);
    }
}


Convert.IsGradientBrush = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is GradientBrush</param>
    return CheckConvertIs(",GradientBrush,LinearGradientBrush,RadialGradientBrush,", javascriptObject, false);
}

Convert.ToGradientBrush = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to GradientBrush</param>
    /// <returns type="GradientBrush" />
    if (!Convert.IsGradientBrush(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new GradientBrush(javascriptObject.element)
        else
            return new GradientBrush(javascriptObject);
    }
}


Convert.IsLinearGradientBrush = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is LinearGradientBrush</param>
    return CheckConvertIs(",LinearGradientBrush,", javascriptObject, false);
}

Convert.ToLinearGradientBrush = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to LinearGradientBrush</param>
    /// <returns type="LinearGradientBrush" />
    if (!Convert.IsLinearGradientBrush(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new LinearGradientBrush(javascriptObject.element)
        else
            return new LinearGradientBrush(javascriptObject);
    }
}


Convert.IsRadialGradientBrush = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is RadialGradientBrush</param>
    return CheckConvertIs(",RadialGradientBrush,", javascriptObject, false);
}

Convert.ToRadialGradientBrush = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to RadialGradientBrush</param>
    /// <returns type="RadialGradientBrush" />
    if (!Convert.IsRadialGradientBrush(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new RadialGradientBrush(javascriptObject.element)
        else
            return new RadialGradientBrush(javascriptObject);
    }
}


Convert.IsImageBrush = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is ImageBrush</param>
    return CheckConvertIs(",ImageBrush,", javascriptObject, false);
}

Convert.ToImageBrush = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to ImageBrush</param>
    /// <returns type="ImageBrush" />
    if (!Convert.IsImageBrush(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new ImageBrush(javascriptObject.element)
        else
            return new ImageBrush(javascriptObject);
    }
}


Convert.IsVideoBrush = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is VideoBrush</param>
    return CheckConvertIs(",VideoBrush,", javascriptObject, false);
}

Convert.ToVideoBrush = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to VideoBrush</param>
    /// <returns type="VideoBrush" />
    if (!Convert.IsVideoBrush(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new VideoBrush(javascriptObject.element)
        else
            return new VideoBrush(javascriptObject);
    }
}


Convert.IsVisualCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is VisualCollection</param>
    return CheckConvertIs(",VisualCollection,", javascriptObject, false);
}

Convert.ToVisualCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to VisualCollection</param>
    /// <returns type="VisualCollection" />
    if (!Convert.IsVisualCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new VisualCollection(javascriptObject.element)
        else
            return new VisualCollection(javascriptObject);
    }
}


Convert.IsTimelineCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is TimelineCollection</param>
    return CheckConvertIs(",TimelineCollection,", javascriptObject, false);
}

Convert.ToTimelineCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to TimelineCollection</param>
    /// <returns type="TimelineCollection" />
    if (!Convert.IsTimelineCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new TimelineCollection(javascriptObject.element)
        else
            return new TimelineCollection(javascriptObject);
    }
}


Convert.IsMediaAttribute = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is MediaAttribute</param>
    return CheckConvertIs(",MediaAttribute,", javascriptObject, false);
}

Convert.ToMediaAttribute = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to MediaAttribute</param>
    /// <returns type="MediaAttribute" />
    if (!Convert.IsMediaAttribute(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new MediaAttribute(javascriptObject.element)
        else
            return new MediaAttribute(javascriptObject);
    }
}


Convert.IsMediaAttributeCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is MediaAttributeCollection</param>
    return CheckConvertIs(",MediaAttributeCollection,", javascriptObject, false);
}

Convert.ToMediaAttributeCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to MediaAttributeCollection</param>
    /// <returns type="MediaAttributeCollection" />
    if (!Convert.IsMediaAttributeCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new MediaAttributeCollection(javascriptObject.element)
        else
            return new MediaAttributeCollection(javascriptObject);
    }
}


Convert.IsFillBehavior = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is FillBehavior</param>
    return CheckConvertIs(",FillBehavior,", javascriptObject, true);
}

Convert.ToFillBehavior = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to FillBehavior</param>
    /// <returns type="FillBehavior" />
    if (!Convert.IsFillBehavior(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new FillBehavior(javascriptObject.element)
        else
            return new FillBehavior(javascriptObject);
    }
}


Convert.IsTimeline = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Timeline</param>
    return CheckConvertIs(",Timeline,TimelineGroup,ParallelTimeline,Storyboard,Animation,DoubleAnimation,ColorAnimation,PointAnimation,DoubleAnimationUsingKeyFrames,ColorAnimationUsingKeyFrames,PointAnimationUsingKeyFrames,", javascriptObject, false);
}

Convert.ToTimeline = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Timeline</param>
    /// <returns type="Timeline" />
    if (!Convert.IsTimeline(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Timeline(javascriptObject.element)
        else
            return new Timeline(javascriptObject);
    }
}


Convert.IsTimelineGroup = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is TimelineGroup</param>
    return CheckConvertIs(",TimelineGroup,ParallelTimeline,Storyboard,", javascriptObject, false);
}

Convert.ToTimelineGroup = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to TimelineGroup</param>
    /// <returns type="TimelineGroup" />
    if (!Convert.IsTimelineGroup(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new TimelineGroup(javascriptObject.element)
        else
            return new TimelineGroup(javascriptObject);
    }
}


Convert.IsParallelTimeline = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is ParallelTimeline</param>
    return CheckConvertIs(",ParallelTimeline,Storyboard,", javascriptObject, false);
}

Convert.ToParallelTimeline = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to ParallelTimeline</param>
    /// <returns type="ParallelTimeline" />
    if (!Convert.IsParallelTimeline(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new ParallelTimeline(javascriptObject.element)
        else
            return new ParallelTimeline(javascriptObject);
    }
}


Convert.IsBeginStoryboard = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is BeginStoryboard</param>
    return CheckConvertIs(",BeginStoryboard,", javascriptObject, false);
}

Convert.ToBeginStoryboard = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to BeginStoryboard</param>
    /// <returns type="BeginStoryboard" />
    if (!Convert.IsBeginStoryboard(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new BeginStoryboard(javascriptObject.element)
        else
            return new BeginStoryboard(javascriptObject);
    }
}


Convert.IsStoryboard = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Storyboard</param>
    return CheckConvertIs(",Storyboard,", javascriptObject, false);
}

Convert.ToStoryboard = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Storyboard</param>
    /// <returns type="Storyboard" />
    if (!Convert.IsStoryboard(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Storyboard(javascriptObject.element)
        else
            return new Storyboard(javascriptObject);
    }
}


Convert.IsAnimation = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Animation</param>
    return CheckConvertIs(",Animation,DoubleAnimation,ColorAnimation,PointAnimation,DoubleAnimationUsingKeyFrames,ColorAnimationUsingKeyFrames,PointAnimationUsingKeyFrames,", javascriptObject, false);
}

Convert.ToAnimation = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Animation</param>
    /// <returns type="Animation" />
    if (!Convert.IsAnimation(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Animation(javascriptObject.element)
        else
            return new Animation(javascriptObject);
    }
}


Convert.IsDoubleAnimation = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is DoubleAnimation</param>
    return CheckConvertIs(",DoubleAnimation,DoubleAnimationUsingKeyFrames,", javascriptObject, false);
}

Convert.ToDoubleAnimation = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to DoubleAnimation</param>
    /// <returns type="DoubleAnimation" />
    if (!Convert.IsDoubleAnimation(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new DoubleAnimation(javascriptObject.element)
        else
            return new DoubleAnimation(javascriptObject);
    }
}


Convert.IsColorAnimation = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is ColorAnimation</param>
    return CheckConvertIs(",ColorAnimation,ColorAnimationUsingKeyFrames,", javascriptObject, false);
}

Convert.ToColorAnimation = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to ColorAnimation</param>
    /// <returns type="ColorAnimation" />
    if (!Convert.IsColorAnimation(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new ColorAnimation(javascriptObject.element)
        else
            return new ColorAnimation(javascriptObject);
    }
}


Convert.IsPointAnimation = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is PointAnimation</param>
    return CheckConvertIs(",PointAnimation,PointAnimationUsingKeyFrames,", javascriptObject, false);
}

Convert.ToPointAnimation = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to PointAnimation</param>
    /// <returns type="PointAnimation" />
    if (!Convert.IsPointAnimation(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new PointAnimation(javascriptObject.element)
        else
            return new PointAnimation(javascriptObject);
    }
}


Convert.IsKeySpline = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is KeySpline</param>
    return CheckConvertIs(",KeySpline,", javascriptObject, false);
}

Convert.ToKeySpline = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to KeySpline</param>
    /// <returns type="KeySpline" />
    if (!Convert.IsKeySpline(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new KeySpline(javascriptObject.element)
        else
            return new KeySpline(javascriptObject);
    }
}


Convert.IsKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is KeyFrame</param>
    return CheckConvertIs(",KeyFrame,DoubleKeyFrame,DiscreteDoubleKeyFrame,LinearDoubleKeyFrame,SplineDoubleKeyFrame,ColorKeyFrame,DiscreteColorKeyFrame,LinearColorKeyFrame,SplineColorKeyFrame,PointKeyFrame,DiscretePointKeyFrame,LinearPointKeyFrame,SplinePointKeyFrame,", javascriptObject, false);
}

Convert.ToKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to KeyFrame</param>
    /// <returns type="KeyFrame" />
    if (!Convert.IsKeyFrame(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new KeyFrame(javascriptObject.element)
        else
            return new KeyFrame(javascriptObject);
    }
}


Convert.IsColorKeyFrameCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is ColorKeyFrameCollection</param>
    return CheckConvertIs(",ColorKeyFrameCollection,", javascriptObject, false);
}

Convert.ToColorKeyFrameCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to ColorKeyFrameCollection</param>
    /// <returns type="ColorKeyFrameCollection" />
    if (!Convert.IsColorKeyFrameCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new ColorKeyFrameCollection(javascriptObject.element)
        else
            return new ColorKeyFrameCollection(javascriptObject);
    }
}


Convert.IsDoubleKeyFrameCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is DoubleKeyFrameCollection</param>
    return CheckConvertIs(",DoubleKeyFrameCollection,", javascriptObject, false);
}

Convert.ToDoubleKeyFrameCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to DoubleKeyFrameCollection</param>
    /// <returns type="DoubleKeyFrameCollection" />
    if (!Convert.IsDoubleKeyFrameCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new DoubleKeyFrameCollection(javascriptObject.element)
        else
            return new DoubleKeyFrameCollection(javascriptObject);
    }
}


Convert.IsPointKeyFrameCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is PointKeyFrameCollection</param>
    return CheckConvertIs(",PointKeyFrameCollection,", javascriptObject, false);
}

Convert.ToPointKeyFrameCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to PointKeyFrameCollection</param>
    /// <returns type="PointKeyFrameCollection" />
    if (!Convert.IsPointKeyFrameCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new PointKeyFrameCollection(javascriptObject.element)
        else
            return new PointKeyFrameCollection(javascriptObject);
    }
}


Convert.IsDoubleAnimationUsingKeyFrames = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is DoubleAnimationUsingKeyFrames</param>
    return CheckConvertIs(",DoubleAnimationUsingKeyFrames,", javascriptObject, false);
}

Convert.ToDoubleAnimationUsingKeyFrames = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to DoubleAnimationUsingKeyFrames</param>
    /// <returns type="DoubleAnimationUsingKeyFrames" />
    if (!Convert.IsDoubleAnimationUsingKeyFrames(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new DoubleAnimationUsingKeyFrames(javascriptObject.element)
        else
            return new DoubleAnimationUsingKeyFrames(javascriptObject);
    }
}


Convert.IsDoubleKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is DoubleKeyFrame</param>
    return CheckConvertIs(",DoubleKeyFrame,DiscreteDoubleKeyFrame,LinearDoubleKeyFrame,SplineDoubleKeyFrame,", javascriptObject, false);
}

Convert.ToDoubleKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to DoubleKeyFrame</param>
    /// <returns type="DoubleKeyFrame" />
    if (!Convert.IsDoubleKeyFrame(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new DoubleKeyFrame(javascriptObject.element)
        else
            return new DoubleKeyFrame(javascriptObject);
    }
}


Convert.IsDiscreteDoubleKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is DiscreteDoubleKeyFrame</param>
    return CheckConvertIs(",DiscreteDoubleKeyFrame,", javascriptObject, false);
}

Convert.ToDiscreteDoubleKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to DiscreteDoubleKeyFrame</param>
    /// <returns type="DiscreteDoubleKeyFrame" />
    if (!Convert.IsDiscreteDoubleKeyFrame(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new DiscreteDoubleKeyFrame(javascriptObject.element)
        else
            return new DiscreteDoubleKeyFrame(javascriptObject);
    }
}


Convert.IsLinearDoubleKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is LinearDoubleKeyFrame</param>
    return CheckConvertIs(",LinearDoubleKeyFrame,", javascriptObject, false);
}

Convert.ToLinearDoubleKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to LinearDoubleKeyFrame</param>
    /// <returns type="LinearDoubleKeyFrame" />
    if (!Convert.IsLinearDoubleKeyFrame(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new LinearDoubleKeyFrame(javascriptObject.element)
        else
            return new LinearDoubleKeyFrame(javascriptObject);
    }
}


Convert.IsSplineDoubleKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is SplineDoubleKeyFrame</param>
    return CheckConvertIs(",SplineDoubleKeyFrame,", javascriptObject, false);
}

Convert.ToSplineDoubleKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to SplineDoubleKeyFrame</param>
    /// <returns type="SplineDoubleKeyFrame" />
    if (!Convert.IsSplineDoubleKeyFrame(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new SplineDoubleKeyFrame(javascriptObject.element)
        else
            return new SplineDoubleKeyFrame(javascriptObject);
    }
}


Convert.IsColorAnimationUsingKeyFrames = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is ColorAnimationUsingKeyFrames</param>
    return CheckConvertIs(",ColorAnimationUsingKeyFrames,", javascriptObject, false);
}

Convert.ToColorAnimationUsingKeyFrames = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to ColorAnimationUsingKeyFrames</param>
    /// <returns type="ColorAnimationUsingKeyFrames" />
    if (!Convert.IsColorAnimationUsingKeyFrames(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new ColorAnimationUsingKeyFrames(javascriptObject.element)
        else
            return new ColorAnimationUsingKeyFrames(javascriptObject);
    }
}


Convert.IsColorKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is ColorKeyFrame</param>
    return CheckConvertIs(",ColorKeyFrame,DiscreteColorKeyFrame,LinearColorKeyFrame,SplineColorKeyFrame,", javascriptObject, false);
}

Convert.ToColorKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to ColorKeyFrame</param>
    /// <returns type="ColorKeyFrame" />
    if (!Convert.IsColorKeyFrame(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new ColorKeyFrame(javascriptObject.element)
        else
            return new ColorKeyFrame(javascriptObject);
    }
}


Convert.IsDiscreteColorKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is DiscreteColorKeyFrame</param>
    return CheckConvertIs(",DiscreteColorKeyFrame,", javascriptObject, false);
}

Convert.ToDiscreteColorKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to DiscreteColorKeyFrame</param>
    /// <returns type="DiscreteColorKeyFrame" />
    if (!Convert.IsDiscreteColorKeyFrame(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new DiscreteColorKeyFrame(javascriptObject.element)
        else
            return new DiscreteColorKeyFrame(javascriptObject);
    }
}


Convert.IsLinearColorKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is LinearColorKeyFrame</param>
    return CheckConvertIs(",LinearColorKeyFrame,", javascriptObject, false);
}

Convert.ToLinearColorKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to LinearColorKeyFrame</param>
    /// <returns type="LinearColorKeyFrame" />
    if (!Convert.IsLinearColorKeyFrame(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new LinearColorKeyFrame(javascriptObject.element)
        else
            return new LinearColorKeyFrame(javascriptObject);
    }
}


Convert.IsSplineColorKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is SplineColorKeyFrame</param>
    return CheckConvertIs(",SplineColorKeyFrame,", javascriptObject, false);
}

Convert.ToSplineColorKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to SplineColorKeyFrame</param>
    /// <returns type="SplineColorKeyFrame" />
    if (!Convert.IsSplineColorKeyFrame(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new SplineColorKeyFrame(javascriptObject.element)
        else
            return new SplineColorKeyFrame(javascriptObject);
    }
}


Convert.IsPointAnimationUsingKeyFrames = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is PointAnimationUsingKeyFrames</param>
    return CheckConvertIs(",PointAnimationUsingKeyFrames,", javascriptObject, false);
}

Convert.ToPointAnimationUsingKeyFrames = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to PointAnimationUsingKeyFrames</param>
    /// <returns type="PointAnimationUsingKeyFrames" />
    if (!Convert.IsPointAnimationUsingKeyFrames(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new PointAnimationUsingKeyFrames(javascriptObject.element)
        else
            return new PointAnimationUsingKeyFrames(javascriptObject);
    }
}


Convert.IsPointKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is PointKeyFrame</param>
    return CheckConvertIs(",PointKeyFrame,DiscretePointKeyFrame,LinearPointKeyFrame,SplinePointKeyFrame,", javascriptObject, false);
}

Convert.ToPointKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to PointKeyFrame</param>
    /// <returns type="PointKeyFrame" />
    if (!Convert.IsPointKeyFrame(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new PointKeyFrame(javascriptObject.element)
        else
            return new PointKeyFrame(javascriptObject);
    }
}


Convert.IsDiscretePointKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is DiscretePointKeyFrame</param>
    return CheckConvertIs(",DiscretePointKeyFrame,", javascriptObject, false);
}

Convert.ToDiscretePointKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to DiscretePointKeyFrame</param>
    /// <returns type="DiscretePointKeyFrame" />
    if (!Convert.IsDiscretePointKeyFrame(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new DiscretePointKeyFrame(javascriptObject.element)
        else
            return new DiscretePointKeyFrame(javascriptObject);
    }
}


Convert.IsLinearPointKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is LinearPointKeyFrame</param>
    return CheckConvertIs(",LinearPointKeyFrame,", javascriptObject, false);
}

Convert.ToLinearPointKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to LinearPointKeyFrame</param>
    /// <returns type="LinearPointKeyFrame" />
    if (!Convert.IsLinearPointKeyFrame(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new LinearPointKeyFrame(javascriptObject.element)
        else
            return new LinearPointKeyFrame(javascriptObject);
    }
}


Convert.IsSplinePointKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is SplinePointKeyFrame</param>
    return CheckConvertIs(",SplinePointKeyFrame,", javascriptObject, false);
}

Convert.ToSplinePointKeyFrame = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to SplinePointKeyFrame</param>
    /// <returns type="SplinePointKeyFrame" />
    if (!Convert.IsSplinePointKeyFrame(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new SplinePointKeyFrame(javascriptObject.element)
        else
            return new SplinePointKeyFrame(javascriptObject);
    }
}


Convert.IsTimelineMarker = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is TimelineMarker</param>
    return CheckConvertIs(",TimelineMarker,", javascriptObject, false);
}

Convert.ToTimelineMarker = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to TimelineMarker</param>
    /// <returns type="TimelineMarker" />
    if (!Convert.IsTimelineMarker(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new TimelineMarker(javascriptObject.element)
        else
            return new TimelineMarker(javascriptObject);
    }
}


Convert.IsTimelineMarkerCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is TimelineMarkerCollection</param>
    return CheckConvertIs(",TimelineMarkerCollection,", javascriptObject, false);
}

Convert.ToTimelineMarkerCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to TimelineMarkerCollection</param>
    /// <returns type="TimelineMarkerCollection" />
    if (!Convert.IsTimelineMarkerCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new TimelineMarkerCollection(javascriptObject.element)
        else
            return new TimelineMarkerCollection(javascriptObject);
    }
}


Convert.IsMouseEventHandler = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is MouseEventHandler</param>
    return CheckConvertIs(",MouseEventHandler,", javascriptObject, true);
}

Convert.ToMouseEventHandler = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to MouseEventHandler</param>
    /// <returns type="MouseEventHandler" />
    if (!Convert.IsMouseEventHandler(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new MouseEventHandler(javascriptObject.element)
        else
            return new MouseEventHandler(javascriptObject);
    }
}


Convert.IsKeyboardEventHandler = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is KeyboardEventHandler</param>
    return CheckConvertIs(",KeyboardEventHandler,", javascriptObject, true);
}

Convert.ToKeyboardEventHandler = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to KeyboardEventHandler</param>
    /// <returns type="KeyboardEventHandler" />
    if (!Convert.IsKeyboardEventHandler(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new KeyboardEventHandler(javascriptObject.element)
        else
            return new KeyboardEventHandler(javascriptObject);
    }
}


Convert.IsTimelineMarkerEventHandler = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is TimelineMarkerEventHandler</param>
    return CheckConvertIs(",TimelineMarkerEventHandler,", javascriptObject, true);
}

Convert.ToTimelineMarkerEventHandler = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to TimelineMarkerEventHandler</param>
    /// <returns type="TimelineMarkerEventHandler" />
    if (!Convert.IsTimelineMarkerEventHandler(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new TimelineMarkerEventHandler(javascriptObject.element)
        else
            return new TimelineMarkerEventHandler(javascriptObject);
    }
}


Convert.IsCursors = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Cursors</param>
    return CheckConvertIs(",Cursors,", javascriptObject, true);
}

Convert.ToCursors = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Cursors</param>
    /// <returns type="Cursors" />
    if (!Convert.IsCursors(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Cursors(javascriptObject.element)
        else
            return new Cursors(javascriptObject);
    }
}


Convert.IsTabletDeviceType = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is TabletDeviceType</param>
    return CheckConvertIs(",TabletDeviceType,", javascriptObject, true);
}

Convert.ToTabletDeviceType = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to TabletDeviceType</param>
    /// <returns type="TabletDeviceType" />
    if (!Convert.IsTabletDeviceType(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new TabletDeviceType(javascriptObject.element)
        else
            return new TabletDeviceType(javascriptObject);
    }
}


Convert.IsStylusPoint = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is StylusPoint</param>
    return CheckConvertIs(",StylusPoint,", javascriptObject, false);
}

Convert.ToStylusPoint = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to StylusPoint</param>
    /// <returns type="StylusPoint" />
    if (!Convert.IsStylusPoint(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new StylusPoint(javascriptObject.element)
        else
            return new StylusPoint(javascriptObject);
    }
}


Convert.IsStylusPointCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is StylusPointCollection</param>
    return CheckConvertIs(",StylusPointCollection,", javascriptObject, false);
}

Convert.ToStylusPointCollection = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to StylusPointCollection</param>
    /// <returns type="StylusPointCollection" />
    if (!Convert.IsStylusPointCollection(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new StylusPointCollection(javascriptObject.element)
        else
            return new StylusPointCollection(javascriptObject);
    }
}


Convert.IsMouseEventArgs = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is MouseEventArgs</param>
    return CheckConvertIs(",MouseEventArgs,", javascriptObject, true);
}

Convert.ToMouseEventArgs = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to MouseEventArgs</param>
    /// <returns type="MouseEventArgs" />
    if (!Convert.IsMouseEventArgs(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new MouseEventArgs(javascriptObject.element)
        else
            return new MouseEventArgs(javascriptObject);
    }
}


Convert.IsKeyboardEventArgs = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is KeyboardEventArgs</param>
    return CheckConvertIs(",KeyboardEventArgs,", javascriptObject, true);
}

Convert.ToKeyboardEventArgs = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to KeyboardEventArgs</param>
    /// <returns type="KeyboardEventArgs" />
    if (!Convert.IsKeyboardEventArgs(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new KeyboardEventArgs(javascriptObject.element)
        else
            return new KeyboardEventArgs(javascriptObject);
    }
}


Convert.IsTimelineMarkerEventArgs = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is TimelineMarkerEventArgs</param>
    return CheckConvertIs(",TimelineMarkerEventArgs,", javascriptObject, true);
}

Convert.ToTimelineMarkerEventArgs = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to TimelineMarkerEventArgs</param>
    /// <returns type="TimelineMarkerEventArgs" />
    if (!Convert.IsTimelineMarkerEventArgs(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new TimelineMarkerEventArgs(javascriptObject.element)
        else
            return new TimelineMarkerEventArgs(javascriptObject);
    }
}


Convert.IsStylusInfo = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is StylusInfo</param>
    return CheckConvertIs(",StylusInfo,", javascriptObject, false);
}

Convert.ToStylusInfo = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to StylusInfo</param>
    /// <returns type="StylusInfo" />
    if (!Convert.IsStylusInfo(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new StylusInfo(javascriptObject.element)
        else
            return new StylusInfo(javascriptObject);
    }
}


Convert.IsShape = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Shape</param>
    return CheckConvertIs(",Shape,Path,Ellipse,Line,Polygon,Polyline,Rectangle,", javascriptObject, false);
}

Convert.ToShape = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Shape</param>
    /// <returns type="Shape" />
    if (!Convert.IsShape(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Shape(javascriptObject.element)
        else
            return new Shape(javascriptObject);
    }
}


Convert.IsPath = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Path</param>
    return CheckConvertIs(",Path,", javascriptObject, false);
}

Convert.ToPath = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Path</param>
    /// <returns type="Path" />
    if (!Convert.IsPath(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Path(javascriptObject.element)
        else
            return new Path(javascriptObject);
    }
}


Convert.IsEllipse = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Ellipse</param>
    return CheckConvertIs(",Ellipse,", javascriptObject, false);
}

Convert.ToEllipse = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Ellipse</param>
    /// <returns type="Ellipse" />
    if (!Convert.IsEllipse(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Ellipse(javascriptObject.element)
        else
            return new Ellipse(javascriptObject);
    }
}


Convert.IsLine = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Line</param>
    return CheckConvertIs(",Line,", javascriptObject, false);
}

Convert.ToLine = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Line</param>
    /// <returns type="Line" />
    if (!Convert.IsLine(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Line(javascriptObject.element)
        else
            return new Line(javascriptObject);
    }
}


Convert.IsPolygon = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Polygon</param>
    return CheckConvertIs(",Polygon,", javascriptObject, false);
}

Convert.ToPolygon = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Polygon</param>
    /// <returns type="Polygon" />
    if (!Convert.IsPolygon(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Polygon(javascriptObject.element)
        else
            return new Polygon(javascriptObject);
    }
}


Convert.IsPolyline = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Polyline</param>
    return CheckConvertIs(",Polyline,", javascriptObject, false);
}

Convert.ToPolyline = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Polyline</param>
    /// <returns type="Polyline" />
    if (!Convert.IsPolyline(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Polyline(javascriptObject.element)
        else
            return new Polyline(javascriptObject);
    }
}


Convert.IsRectangle = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Rectangle</param>
    return CheckConvertIs(",Rectangle,", javascriptObject, false);
}

Convert.ToRectangle = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Rectangle</param>
    /// <returns type="Rectangle" />
    if (!Convert.IsRectangle(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Rectangle(javascriptObject.element)
        else
            return new Rectangle(javascriptObject);
    }
}


Convert.IsInline = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Inline</param>
    return CheckConvertIs(",Inline,Run,LineBreak,", javascriptObject, false);
}

Convert.ToInline = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Inline</param>
    /// <returns type="Inline" />
    if (!Convert.IsInline(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Inline(javascriptObject.element)
        else
            return new Inline(javascriptObject);
    }
}


Convert.IsGlyphs = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Glyphs</param>
    return CheckConvertIs(",Glyphs,", javascriptObject, false);
}

Convert.ToGlyphs = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Glyphs</param>
    /// <returns type="Glyphs" />
    if (!Convert.IsGlyphs(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Glyphs(javascriptObject.element)
        else
            return new Glyphs(javascriptObject);
    }
}


Convert.IsRun = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Run</param>
    return CheckConvertIs(",Run,", javascriptObject, false);
}

Convert.ToRun = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Run</param>
    /// <returns type="Run" />
    if (!Convert.IsRun(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Run(javascriptObject.element)
        else
            return new Run(javascriptObject);
    }
}


Convert.IsLineBreak = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is LineBreak</param>
    return CheckConvertIs(",LineBreak,", javascriptObject, false);
}

Convert.ToLineBreak = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to LineBreak</param>
    /// <returns type="LineBreak" />
    if (!Convert.IsLineBreak(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new LineBreak(javascriptObject.element)
        else
            return new LineBreak(javascriptObject);
    }
}


Convert.IsPanel = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Panel</param>
    return CheckConvertIs(",Panel,Canvas,InkPresenter,", javascriptObject, false);
}

Convert.ToPanel = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Panel</param>
    /// <returns type="Panel" />
    if (!Convert.IsPanel(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Panel(javascriptObject.element)
        else
            return new Panel(javascriptObject);
    }
}


Convert.IsMediaBase = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is MediaBase</param>
    return CheckConvertIs(",MediaBase,ImageSL,MediaElement,", javascriptObject, false);
}

Convert.ToMediaBase = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to MediaBase</param>
    /// <returns type="MediaBase" />
    if (!Convert.IsMediaBase(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new MediaBase(javascriptObject.element)
        else
            return new MediaBase(javascriptObject);
    }
}


Convert.IsImageSL = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is ImageSL</param>
    return CheckConvertIs(",ImageSL,", javascriptObject, false);
}

Convert.ToImageSL = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to ImageSL</param>
    /// <returns type="ImageSL" />
    if (!Convert.IsImageSL(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new ImageSL(javascriptObject.element)
        else
            return new ImageSL(javascriptObject);
    }
}


Convert.IsCanvas = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Canvas</param>
    return CheckConvertIs(",Canvas,InkPresenter,", javascriptObject, false);
}

Convert.ToCanvas = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Canvas</param>
    /// <returns type="Canvas" />
    if (!Convert.IsCanvas(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Canvas(javascriptObject.element)
        else
            return new Canvas(javascriptObject);
    }
}


Convert.IsTextBlock = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is TextBlock</param>
    return CheckConvertIs(",TextBlock,", javascriptObject, false);
}

Convert.ToTextBlock = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to TextBlock</param>
    /// <returns type="TextBlock" />
    if (!Convert.IsTextBlock(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new TextBlock(javascriptObject.element)
        else
            return new TextBlock(javascriptObject);
    }
}


Convert.IsMediaElement = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is MediaElement</param>
    return CheckConvertIs(",MediaElement,", javascriptObject, false);
}

Convert.ToMediaElement = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to MediaElement</param>
    /// <returns type="MediaElement" />
    if (!Convert.IsMediaElement(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new MediaElement(javascriptObject.element)
        else
            return new MediaElement(javascriptObject);
    }
}


Convert.IsInkPresenter = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is InkPresenter</param>
    return CheckConvertIs(",InkPresenter,", javascriptObject, false);
}

Convert.ToInkPresenter = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to InkPresenter</param>
    /// <returns type="InkPresenter" />
    if (!Convert.IsInkPresenter(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new InkPresenter(javascriptObject.element)
        else
            return new InkPresenter(javascriptObject);
    }
}


Convert.IsControl = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Control</param>
    return CheckConvertIs(",Control,", javascriptObject, false);
}

Convert.ToControl = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Control</param>
    /// <returns type="Control" />
    if (!Convert.IsControl(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Control(javascriptObject.element)
        else
            return new Control(javascriptObject);
    }
}


Convert.IsDuration = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Duration</param>
    return CheckConvertIs(",Duration,", javascriptObject, true);
}

Convert.ToDuration = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Duration</param>
    /// <returns type="Duration" />
    if (!Convert.IsDuration(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Duration(javascriptObject.element)
        else
            return new Duration(javascriptObject);
    }
}


Convert.IsXamlParseException = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is XamlParseException</param>
    return CheckConvertIs(",XamlParseException,", javascriptObject, true);
}

Convert.ToXamlParseException = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to XamlParseException</param>
    /// <returns type="XamlParseException" />
    if (!Convert.IsXamlParseException(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new XamlParseException(javascriptObject.element)
        else
            return new XamlParseException(javascriptObject);
    }
}


Convert.IsBrowserHost = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is BrowserHost</param>
    return CheckConvertIs(",BrowserHost,", javascriptObject, true);
}

Convert.ToBrowserHost = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to BrowserHost</param>
    /// <returns type="BrowserHost" />
    if (!Convert.IsBrowserHost(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new BrowserHost(javascriptObject.element)
        else
            return new BrowserHost(javascriptObject);
    }
}


Convert.IsRepeatBehavior = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is RepeatBehavior</param>
    return CheckConvertIs(",RepeatBehavior,", javascriptObject, true);
}

Convert.ToRepeatBehavior = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to RepeatBehavior</param>
    /// <returns type="RepeatBehavior" />
    if (!Convert.IsRepeatBehavior(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new RepeatBehavior(javascriptObject.element)
        else
            return new RepeatBehavior(javascriptObject);
    }
}


Convert.IsKeyTime = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is KeyTime</param>
    return CheckConvertIs(",KeyTime,", javascriptObject, true);
}

Convert.ToKeyTime = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to KeyTime</param>
    /// <returns type="KeyTime" />
    if (!Convert.IsKeyTime(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new KeyTime(javascriptObject.element)
        else
            return new KeyTime(javascriptObject);
    }
}


Convert.IsKeyTimeType = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is KeyTimeType</param>
    return CheckConvertIs(",KeyTimeType,", javascriptObject, true);
}

Convert.ToKeyTimeType = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to KeyTimeType</param>
    /// <returns type="KeyTimeType" />
    if (!Convert.IsKeyTimeType(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new KeyTimeType(javascriptObject.element)
        else
            return new KeyTimeType(javascriptObject);
    }
}


Convert.IsMatrix = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Matrix</param>
    return CheckConvertIs(",Matrix,", javascriptObject, true);
}

Convert.ToMatrix = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Matrix</param>
    /// <returns type="Matrix" />
    if (!Convert.IsMatrix(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Matrix(javascriptObject.element)
        else
            return new Matrix(javascriptObject);
    }
}


Convert.IsRect = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Rect</param>
    return CheckConvertIs(",Rect,", javascriptObject, true);
}

Convert.ToRect = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Rect</param>
    /// <returns type="Rect" />
    if (!Convert.IsRect(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Rect(javascriptObject.element)
        else
            return new Rect(javascriptObject);
    }
}


Convert.IsPoint = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Point</param>
    return CheckConvertIs(",Point,", javascriptObject, true);
}

Convert.ToPoint = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Point</param>
    /// <returns type="Point" />
    if (!Convert.IsPoint(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Point(javascriptObject.element)
        else
            return new Point(javascriptObject);
    }
}


Convert.IsSize = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Size</param>
    return CheckConvertIs(",Size,", javascriptObject, true);
}

Convert.ToSize = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Size</param>
    /// <returns type="Size" />
    if (!Convert.IsSize(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Size(javascriptObject.element)
        else
            return new Size(javascriptObject);
    }
}


Convert.IsColor = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Color</param>
    return CheckConvertIs(",Color,", javascriptObject, true);
}

Convert.ToColor = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Color</param>
    /// <returns type="Color" />
    if (!Convert.IsColor(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Color(javascriptObject.element)
        else
            return new Color(javascriptObject);
    }
}


Convert.IsColors = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is Colors</param>
    return CheckConvertIs(",Colors,", javascriptObject, true);
}

Convert.ToColors = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to Colors</param>
    /// <returns type="Colors" />
    if (!Convert.IsColors(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new Colors(javascriptObject.element)
        else
            return new Colors(javascriptObject);
    }
}


Convert.IsXamlReader = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is XamlReader</param>
    return CheckConvertIs(",XamlReader,", javascriptObject, true);
}

Convert.ToXamlReader = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to XamlReader</param>
    /// <returns type="XamlReader" />
    if (!Convert.IsXamlReader(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new XamlReader(javascriptObject.element)
        else
            return new XamlReader(javascriptObject);
    }
}


Convert.IsDependencyProperty = function(javascriptObject)
{
    /// <param name="javascriptObject">object to check if is DependencyProperty</param>
    return CheckConvertIs(",DependencyProperty,", javascriptObject, true);
}

Convert.ToDependencyProperty = function(javascriptObject)
{
    /// <param name="javascriptObject">object to convert to DependencyProperty</param>
    /// <returns type="DependencyProperty" />
    if (!Convert.IsDependencyProperty(javascriptObject))
        return;
    else
    {
        if (HasElementProperty(javascriptObject))
            return new DependencyProperty(javascriptObject.element)
        else
            return new DependencyProperty(javascriptObject);
    }
}

function TypeSafety(paramsToValidate)
{
    var isValid = true;
    for(var paramType  in paramsToValidate)
    {
        var paramValue = paramsToValidate[paramType];
        var ConvertIs = eval("Convert.Is" + paramType);
        if (ConvertIs)
        {
           if (!ConvertIs(paramValue))
           {
                isValid = false;
           }
        }
        
        if ((paramType == "String") && !IsString(paramValue))
            isValid = false;
       
        if (((paramType == "Number") || (paramType == "Double")) && !IsNumber(paramValue))
            isValid = false;
            
        if ((paramType == "Function") && !IsFunction(paramValue))
            isValid = false;
              
        if ((paramType == "Boolean") && !IsBoolean(paramValue))
            isValid = false;
                  
        if (!isValid)
            throw new Error(paramValue + " is not of type " + paramType);
    }
}

function IsPrimitive(value) 
{ 
    return IsString(value) || IsNumber(value) || IsFunction(value) || IsBoolean(value); 
}

function IsString(value) 
{ 
    return (value  != null) && (value.toLowerCase != null); 
}

function IsNumber(value) 
{
    return (value != null) && (value.toPrecision != null);
}

function IsFunction(value) 
{
    return  (value != null) && (value.apply != null); 
}

function IsBoolean(value) 
{ 
    return (value != null) && ((value == true) || (value == false)); 
}

function HasElementProperty(value)
{
    try {  return (value != null) && (value.element != null); }
    catch(ex) { return false;  }
}

function CheckConvertIs(typeHierchy, javascriptObject, canBePrimitive)
{
        if (!javascriptObject)
            return false;
        if (!javascriptObject.toString())
            return false;
        var IsInTypeHierchy = typeHierchy.indexOf(',' + javascriptObject.toString() + ',') != -1;
        if (IsInTypeHierchy)
            return true;
        if (canBePrimitive)
        {
            if (HasElementProperty(javascriptObject))
                return IsPrimitive(javascriptObject.element);
            else
                return IsPrimitive(javascriptObject);
        }
                
}



Host = function(HostXamlElement) 
{
        /// <summary></summary>
        /// <param name="HostXamlElement">Non strongly typed Xaml Element</param>
        this.element = HostXamlElement;
}

Host.prototype.get_initParams = function()
{
    /// <summary>Specifies a string that represents a set of user-defined initialization parameters. The string format of the params value is user-defined.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.initParams);
}

Host.prototype.get_isLoaded = function()
{
    /// <summary>true if the Silverlight control is loaded; otherwise, false. The IsLoaded property is set to true after the XAML content in the Silverlight control has completely loaded, but before the OnLoad event occurs.</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.isLoaded);
}

Host.prototype.get_source = function()
{
    /// <summary>Specifies the XAML content to render.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.source);
}

Host.prototype.get_content = function()
{
    /// <summary></summary>
    /// <returns type="Content" integer="False" />   
    return new Content(this.element.content);
}

Host.prototype.get_settings = function()
{
    /// <summary></summary>
    /// <returns type="Settings" integer="False" />   
    return new Settings(this.element.settings);
}

Host.prototype.createObject = function(objectType)
{
     /// <summary>The Downloader object is the only object that can by specified as the objectType parameter for the CreateObject method. If you specify an invalid objectType parameter, the CreateObject method throws an exception.An object reference if the object was successfully created.</summary>
    /// <param name="objectType" type="String" integer="False" >The type of object to create.</param>   
    /// <returns type="Downloader" integer="False" />   
    TypeSafety({"String":objectType});
    return Convert.ToDownloader(this.element.createObject(objectType));
}

Host.prototype.add_OnError = function(handler) {
    /// <summary>Occurs when the Silverlight control generates a runtime error.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    this.element.OnError = handler;
}

Host.prototype.get_element = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

Content = function(ContentXamlElement) 
{
        /// <summary></summary>
        /// <param name="ContentXamlElement">Non strongly typed Xaml Element</param>
        this.element = ContentXamlElement;
}

Content.prototype.get_actualHeight = function()
{
    /// <summary>Specifies the height of the rendering area of the Silverlight control.</summary>
    /// <returns type="Number" integer="True" />   
    return (this.element.actualHeight);
}

Content.prototype.get_actualWidth = function()
{
    /// <summary>Specifies the width of the rendering area of the Silverlight control.</summary>
    /// <returns type="Number" integer="True" />   
    return (this.element.actualWidth);
}

Content.prototype.set_fullScreen = function(value)
{
    /// <summary>Determines whether the Silverlight control displays as a full-screen control.</summary>
    /// <param name="value" type="Boolean" integer="False" />
    TypeSafety({"Boolean" : value});   
    this.element.fullScreen = value;
}

Content.prototype.get_fullScreen = function()
{
    /// <summary>Determines whether the Silverlight control displays as a full-screen control.</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.fullScreen);
}

Content.prototype.findName = function(objectName)
{
     /// <summary>Gets any object in the Silverlight object hierarchy by referencing the object's x:Name attribute value.A reference to the specified object if the object was successfully found; otherwise, returns null.</summary>
    /// <param name="objectName" type="String" integer="False" >The name of the object to get.</param>   
    /// <returns type="DependencyObject" integer="False" />   
    TypeSafety({"String":objectName});
    return Convert.ToDependencyObject(this.element.findName(objectName));
}

Content.prototype.createFromXaml = function(xamlContent, nameScope)
{
     /// <summary>Creates XAML content dynamically.An object reference if the XAML content was successfully created; otherwise, returns null.</summary>
    /// <param name="xamlContent" type="String" integer="False" >The XAML content to add to the existing Silverlight object hierarchy.</param>   
    /// <param name="nameScope" type="Boolean" integer="False" >Determines whether to create x:Name references in XAML content that do not conflict with other named elements. The nameScope parameter is optional, and its value defaults to false if not specified.</param>   
    /// <returns type="DependencyObject" integer="False" />   
    TypeSafety({"String":xamlContent, "Boolean":nameScope});
    return Convert.ToDependencyObject(this.element.createFromXaml(xamlContent, nameScope));
}

Content.prototype.createFromXamlDownloader = function(downloader, part)
{
     /// <summary>Creates XAML content dynamically using downloader content.An object reference if the XAML content was successfully created; otherwise, returns null.</summary>
    /// <param name="downloader" type="Downloader" integer="False" >The object containing the downloaded content</param>   
    /// <param name="part" type="String" integer="False" >The name of the specific part of the downloaded content package. When the downloaded content package is a Zip file, part refers to the contents of a filename within downloader. If the downloaded content does not represent packaged content, set part to an empty string.</param>   
    /// <returns type="DependencyObject" integer="False" />   
    TypeSafety({"Downloader":downloader, "String":part});
    return Convert.ToDependencyObject(this.element.createFromXamlDownloader(downloader.element, part));
}


Content.prototype.add_OnResize = function(handler) {
    /// <summary>Occurs whenever the ActualHeight or ActualWidth property of the Silverlight control changes.</summary>
    /// <param name="handler" type="Function" />
    TypeSafety({"Function" : handler});
    this.element.OnResize = handler;
}

Content.prototype.add_OnFullScreenChange = function(handler) {
    /// <summary>Occurs whenever the FullScreen property of the Silverlight control changes.</summary>
    /// <param name="handler" type="Function" />
    TypeSafety({"Function" : handler});
    this.element.OnFullScreenChange = handler;
}
    
Content.prototype.get_element = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

Settings = function(SettingsXamlElement) 
{
        /// <summary></summary>
        /// <param name="SettingsXamlElement">Non strongly typed Xaml Element</param>
        this.element = SettingsXamlElement;
}

Settings.prototype.set_background = function(value)
{
    /// <summary>Specifies the background color of the rectangular region that display XAML content.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.background = value;
}

Settings.prototype.get_background = function()
{
    /// <summary>Specifies the background color of the rectangular region that display XAML content.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.background);
}

Settings.prototype.set_enableFramerateCounter = function(value)
{
    /// <summary>Gets or sets a value that determines whether to display the current framerate in the hosting browser's status bar. (Microsoft Internet Explorer only)</summary>
    /// <param name="value" type="Boolean" integer="False" />
    TypeSafety({"Boolean" : value});   
    this.element.enableFramerateCounter = value;
}

Settings.prototype.get_enableFramerateCounter = function()
{
    /// <summary>Gets or sets a value that determines whether to display the current framerate in the hosting browser's status bar. (Microsoft Internet Explorer only)</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.enableFramerateCounter);
}

Settings.prototype.set_enableRedrawRegions = function(value)
{
    /// <summary>Shows the areas of the plug-in that are being redrawn each frame.</summary>
    /// <param name="value" type="Boolean" integer="False" />
    TypeSafety({"Boolean" : value});   
    this.element.enableRedrawRegions = value;
}

Settings.prototype.get_enableRedrawRegions = function()
{
    /// <summary>Shows the areas of the plug-in that are being redrawn each frame.</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.enableRedrawRegions);
}

Settings.prototype.set_enableHtmlAccess = function(value)
{
    /// <summary>Determines whether the hosted content in the Silverlight control has access to the browser Document Object Model (DOM).</summary>
    /// <param name="value" type="Boolean" integer="False" />
    TypeSafety({"Boolean" : value});   
    this.element.enableHtmlAccess = value;
}

Settings.prototype.get_enableHtmlAccess = function()
{
    /// <summary>Determines whether the hosted content in the Silverlight control has access to the browser Document Object Model (DOM).</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.enableHtmlAccess);
}

Settings.prototype.set_maxFrameRate = function(value)
{
    /// <summary>Specifies the maximum number of frames to render per second.</summary>
    /// <param name="value" type="Number" integer="True" />
    TypeSafety({"Number" : value});   
    this.element.maxFrameRate = value;
}

Settings.prototype.get_maxFrameRate = function()
{
    /// <summary>Specifies the maximum number of frames to render per second.</summary>
    /// <returns type="Number" integer="True" />   
    return (this.element.maxFrameRate);
}

Settings.prototype.get_version = function()
{
    /// <summary>Gets the version of the Silverlight control.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.version);
}

Settings.prototype.get_windowless = function()
{
    /// <summary>Determines whether the Silverlight control displays as a window-less control.</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.windowless);
}

Settings.prototype.get_element = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}


ErrorEventHandler = function(ErrorEventHandlerXamlElement) 
{
        /// <summary></summary>
        /// <param name="ErrorEventHandlerXamlElement">Non strongly typed Xaml Element</param>
        this.element = ErrorEventHandlerXamlElement;
}
ErrorEventHandler.prototype.get_method = function()
{
    /// <summary>Gets or sets the type of spread method that specifies how to draw a gradient that starts or ends inside the bounds of the object to be painted.</summary>
    /// <returns type="MethodInfo" integer="False" />   
    return (this.element.method);
}

ErrorEventHandler.prototype.get_target = function()
{
    /// <summary></summary>
    /// <returns type="Object" integer="False" />   
    return (this.element.target);
}

ErrorEventHandler.prototype.invoke = function(sender, e)
{
     /// <summary></summary>
    /// <param name="sender" type="Object" integer="False" ></param>   
    /// <param name="e" type="ErrorEventArgs" integer="False" ></param>   
    TypeSafety({"Object":sender, "ErrorEventArgs":e});
    return (this.element.invoke(sender, e.element));
}

ErrorEventHandler.prototype.beginInvoke = function(sender, e, callback, object)
{
     /// <summary></summary>
    /// <param name="sender" type="Object" integer="False" ></param>   
    /// <param name="e" type="ErrorEventArgs" integer="False" ></param>   
    /// <param name="callback" type="AsyncCallback" integer="False" ></param>   
    /// <param name="object" type="Object" integer="False" ></param>   
    /// <returns type="IAsyncResult" integer="False" />   
    TypeSafety({"Object":sender, "ErrorEventArgs":e, "AsyncCallback":callback, "Object":object});
    return (this.element.beginInvoke(sender, e.element, callback, object));
}

ErrorEventHandler.prototype.endInvoke = function(result)
{
     /// <summary></summary>
    /// <param name="result" type="IAsyncResult" integer="False" ></param>   
    TypeSafety({"IAsyncResult":result});
    return (this.element.endInvoke(result));
}

ErrorEventHandler.prototype.getObjectData = function(info, context)
{
     /// <summary></summary>
    /// <param name="info" type="SerializationInfo" integer="False" ></param>   
    /// <param name="context" type="StreamingContext" integer="False" ></param>   
    TypeSafety({"SerializationInfo":info, "StreamingContext":context});
    return (this.element.getObjectData(info, context));
}

ErrorEventHandler.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

ErrorEventHandler.prototype.getInvocationList = function()
{
     /// <summary></summary>
    /// <returns type="Delegate[]" integer="False" />   
    TypeSafety({});
    return (this.element.getInvocationList());
}

ErrorEventHandler.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

ErrorEventHandler.prototype.dynamicInvoke = function(args)
{
     /// <summary></summary>
    /// <param name="args" type="Object[]" integer="False" ></param>   
    /// <returns type="Object" integer="False" />   
    TypeSafety({"Object[]":args});
    return (this.element.dynamicInvoke(args));
}

ErrorEventHandler.prototype.clone = function()
{
     /// <summary></summary>
    /// <returns type="Object" integer="False" />   
    TypeSafety({});
    return (this.element.clone());
}

ErrorEventHandler.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

ErrorEventHandler.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

ErrorEventHandler.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

ParserErrorEventHandler = function(ParserErrorEventHandlerXamlElement) 
{
        /// <summary></summary>
        /// <param name="ParserErrorEventHandlerXamlElement">Non strongly typed Xaml Element</param>
        this.element = ParserErrorEventHandlerXamlElement;
}
ParserErrorEventHandler.prototype.get_method = function()
{
    /// <summary>Gets or sets the type of spread method that specifies how to draw a gradient that starts or ends inside the bounds of the object to be painted.</summary>
    /// <returns type="MethodInfo" integer="False" />   
    return (this.element.method);
}

ParserErrorEventHandler.prototype.get_target = function()
{
    /// <summary></summary>
    /// <returns type="Object" integer="False" />   
    return (this.element.target);
}

ParserErrorEventHandler.prototype.invoke = function(sender, e)
{
     /// <summary></summary>
    /// <param name="sender" type="Object" integer="False" ></param>   
    /// <param name="e" type="ParserErrorEventArgs" integer="False" ></param>   
    TypeSafety({"Object":sender, "ParserErrorEventArgs":e});
    return (this.element.invoke(sender, e.element));
}

ParserErrorEventHandler.prototype.beginInvoke = function(sender, e, callback, object)
{
     /// <summary></summary>
    /// <param name="sender" type="Object" integer="False" ></param>   
    /// <param name="e" type="ParserErrorEventArgs" integer="False" ></param>   
    /// <param name="callback" type="AsyncCallback" integer="False" ></param>   
    /// <param name="object" type="Object" integer="False" ></param>   
    /// <returns type="IAsyncResult" integer="False" />   
    TypeSafety({"Object":sender, "ParserErrorEventArgs":e, "AsyncCallback":callback, "Object":object});
    return (this.element.beginInvoke(sender, e.element, callback, object));
}

ParserErrorEventHandler.prototype.endInvoke = function(result)
{
     /// <summary></summary>
    /// <param name="result" type="IAsyncResult" integer="False" ></param>   
    TypeSafety({"IAsyncResult":result});
    return (this.element.endInvoke(result));
}

ParserErrorEventHandler.prototype.getObjectData = function(info, context)
{
     /// <summary></summary>
    /// <param name="info" type="SerializationInfo" integer="False" ></param>   
    /// <param name="context" type="StreamingContext" integer="False" ></param>   
    TypeSafety({"SerializationInfo":info, "StreamingContext":context});
    return (this.element.getObjectData(info, context));
}

ParserErrorEventHandler.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

ParserErrorEventHandler.prototype.getInvocationList = function()
{
     /// <summary></summary>
    /// <returns type="Delegate[]" integer="False" />   
    TypeSafety({});
    return (this.element.getInvocationList());
}

ParserErrorEventHandler.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

ParserErrorEventHandler.prototype.dynamicInvoke = function(args)
{
     /// <summary></summary>
    /// <param name="args" type="Object[]" integer="False" ></param>   
    /// <returns type="Object" integer="False" />   
    TypeSafety({"Object[]":args});
    return (this.element.dynamicInvoke(args));
}

ParserErrorEventHandler.prototype.clone = function()
{
     /// <summary></summary>
    /// <returns type="Object" integer="False" />   
    TypeSafety({});
    return (this.element.clone());
}

ParserErrorEventHandler.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

ParserErrorEventHandler.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

ParserErrorEventHandler.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

RuntimeErrorEventHandler = function(RuntimeErrorEventHandlerXamlElement) 
{
        /// <summary></summary>
        /// <param name="RuntimeErrorEventHandlerXamlElement">Non strongly typed Xaml Element</param>
        this.element = RuntimeErrorEventHandlerXamlElement;
}
RuntimeErrorEventHandler.prototype.get_method = function()
{
    /// <summary>Gets or sets the type of spread method that specifies how to draw a gradient that starts or ends inside the bounds of the object to be painted.</summary>
    /// <returns type="MethodInfo" integer="False" />   
    return (this.element.method);
}

RuntimeErrorEventHandler.prototype.get_target = function()
{
    /// <summary></summary>
    /// <returns type="Object" integer="False" />   
    return (this.element.target);
}

RuntimeErrorEventHandler.prototype.invoke = function(sender, e)
{
     /// <summary></summary>
    /// <param name="sender" type="Object" integer="False" ></param>   
    /// <param name="e" type="RuntimeErrorEventArgs" integer="False" ></param>   
    TypeSafety({"Object":sender, "RuntimeErrorEventArgs":e});
    return (this.element.invoke(sender, e.element));
}

RuntimeErrorEventHandler.prototype.beginInvoke = function(sender, e, callback, object)
{
     /// <summary></summary>
    /// <param name="sender" type="Object" integer="False" ></param>   
    /// <param name="e" type="RuntimeErrorEventArgs" integer="False" ></param>   
    /// <param name="callback" type="AsyncCallback" integer="False" ></param>   
    /// <param name="object" type="Object" integer="False" ></param>   
    /// <returns type="IAsyncResult" integer="False" />   
    TypeSafety({"Object":sender, "RuntimeErrorEventArgs":e, "AsyncCallback":callback, "Object":object});
    return (this.element.beginInvoke(sender, e.element, callback, object));
}

RuntimeErrorEventHandler.prototype.endInvoke = function(result)
{
     /// <summary></summary>
    /// <param name="result" type="IAsyncResult" integer="False" ></param>   
    TypeSafety({"IAsyncResult":result});
    return (this.element.endInvoke(result));
}

RuntimeErrorEventHandler.prototype.getObjectData = function(info, context)
{
     /// <summary></summary>
    /// <param name="info" type="SerializationInfo" integer="False" ></param>   
    /// <param name="context" type="StreamingContext" integer="False" ></param>   
    TypeSafety({"SerializationInfo":info, "StreamingContext":context});
    return (this.element.getObjectData(info, context));
}

RuntimeErrorEventHandler.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

RuntimeErrorEventHandler.prototype.getInvocationList = function()
{
     /// <summary></summary>
    /// <returns type="Delegate[]" integer="False" />   
    TypeSafety({});
    return (this.element.getInvocationList());
}

RuntimeErrorEventHandler.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

RuntimeErrorEventHandler.prototype.dynamicInvoke = function(args)
{
     /// <summary></summary>
    /// <param name="args" type="Object[]" integer="False" ></param>   
    /// <returns type="Object" integer="False" />   
    TypeSafety({"Object[]":args});
    return (this.element.dynamicInvoke(args));
}

RuntimeErrorEventHandler.prototype.clone = function()
{
     /// <summary></summary>
    /// <returns type="Object" integer="False" />   
    TypeSafety({});
    return (this.element.clone());
}

RuntimeErrorEventHandler.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

RuntimeErrorEventHandler.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

RuntimeErrorEventHandler.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

TextWrapping = function(TextWrappingXamlElement) 
{
        /// <summary>Specifies whether text wraps when it reaches the edge of the containing box.</summary>
        /// <param name="TextWrappingXamlElement">Non strongly typed Xaml Element</param>
        this.element = TextWrappingXamlElement;
}
TextWrapping.get_Wrap = function()
{
    /// <returns type="TextWrapping" />
    return Convert.ToTextWrapping("Wrap");
}

TextWrapping.is_Wrap = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="TextWrapping" />
    return valueToCompare.element == "Wrap";
}

TextWrapping.get_NoWrap = function()
{
    /// <returns type="TextWrapping" />
    return Convert.ToTextWrapping("NoWrap");
}

TextWrapping.is_NoWrap = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="TextWrapping" />
    return valueToCompare.element == "NoWrap";
}

TextWrapping.get_WrapWithOverflow = function()
{
    /// <returns type="TextWrapping" />
    return Convert.ToTextWrapping("WrapWithOverflow");
}

TextWrapping.is_WrapWithOverflow = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="TextWrapping" />
    return valueToCompare.element == "WrapWithOverflow";
}

TextWrapping.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

TextWrapping.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

TextWrapping.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

TextWrapping.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

TextWrapping.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

TextWrapping.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

TextWrapping.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

TextWrapping.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

TextWrapping.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

TextWrapping.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

FontWeights = function(FontWeightsXamlElement) 
{
        /// <summary></summary>
        /// <param name="FontWeightsXamlElement">Non strongly typed Xaml Element</param>
        this.element = FontWeightsXamlElement;
}
FontWeights.get_Thin = function()
{
    /// <returns type="FontWeights" />
    return Convert.ToFontWeights("Thin");
}

FontWeights.is_Thin = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontWeights" />
    return valueToCompare.element == "Thin";
}

FontWeights.get_ExtraLight = function()
{
    /// <returns type="FontWeights" />
    return Convert.ToFontWeights("ExtraLight");
}

FontWeights.is_ExtraLight = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontWeights" />
    return valueToCompare.element == "ExtraLight";
}

FontWeights.get_Light = function()
{
    /// <returns type="FontWeights" />
    return Convert.ToFontWeights("Light");
}

FontWeights.is_Light = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontWeights" />
    return valueToCompare.element == "Light";
}

FontWeights.get_Normal = function()
{
    /// <returns type="FontWeights" />
    return Convert.ToFontWeights("Normal");
}

FontWeights.is_Normal = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontWeights" />
    return valueToCompare.element == "Normal";
}

FontWeights.get_Medium = function()
{
    /// <returns type="FontWeights" />
    return Convert.ToFontWeights("Medium");
}

FontWeights.is_Medium = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontWeights" />
    return valueToCompare.element == "Medium";
}

FontWeights.get_SemiBold = function()
{
    /// <returns type="FontWeights" />
    return Convert.ToFontWeights("SemiBold");
}

FontWeights.is_SemiBold = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontWeights" />
    return valueToCompare.element == "SemiBold";
}

FontWeights.get_Bold = function()
{
    /// <returns type="FontWeights" />
    return Convert.ToFontWeights("Bold");
}

FontWeights.is_Bold = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontWeights" />
    return valueToCompare.element == "Bold";
}

FontWeights.get_ExtraBold = function()
{
    /// <returns type="FontWeights" />
    return Convert.ToFontWeights("ExtraBold");
}

FontWeights.is_ExtraBold = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontWeights" />
    return valueToCompare.element == "ExtraBold";
}

FontWeights.get_Black = function()
{
    /// <returns type="FontWeights" />
    return Convert.ToFontWeights("Black");
}

FontWeights.is_Black = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontWeights" />
    return valueToCompare.element == "Black";
}

FontWeights.get_ExtraBlack = function()
{
    /// <returns type="FontWeights" />
    return Convert.ToFontWeights("ExtraBlack");
}

FontWeights.is_ExtraBlack = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontWeights" />
    return valueToCompare.element == "ExtraBlack";
}

FontWeights.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

FontWeights.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

FontWeights.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

FontWeights.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

FontWeights.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

FontWeights.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

FontWeights.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

FontWeights.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

FontWeights.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

FontWeights.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

FontStyles = function(FontStylesXamlElement) 
{
        /// <summary></summary>
        /// <param name="FontStylesXamlElement">Non strongly typed Xaml Element</param>
        this.element = FontStylesXamlElement;
}
FontStyles.get_Normal = function()
{
    /// <returns type="FontStyles" />
    return Convert.ToFontStyles("Normal");
}

FontStyles.is_Normal = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontStyles" />
    return valueToCompare.element == "Normal";
}

FontStyles.get_Oblique = function()
{
    /// <returns type="FontStyles" />
    return Convert.ToFontStyles("Oblique");
}

FontStyles.is_Oblique = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontStyles" />
    return valueToCompare.element == "Oblique";
}

FontStyles.get_Italic = function()
{
    /// <returns type="FontStyles" />
    return Convert.ToFontStyles("Italic");
}

FontStyles.is_Italic = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontStyles" />
    return valueToCompare.element == "Italic";
}

FontStyles.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

FontStyles.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

FontStyles.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

FontStyles.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

FontStyles.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

FontStyles.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

FontStyles.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

FontStyles.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

FontStyles.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

FontStyles.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

StyleSimulations = function(StyleSimulationsXamlElement) 
{
        /// <summary>Describes the simulation style of a font.</summary>
        /// <param name="StyleSimulationsXamlElement">Non strongly typed Xaml Element</param>
        this.element = StyleSimulationsXamlElement;
}
StyleSimulations.get_None = function()
{
    /// <returns type="StyleSimulations" />
    return Convert.ToStyleSimulations("None");
}

StyleSimulations.is_None = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="StyleSimulations" />
    return valueToCompare.element == "None";
}

StyleSimulations.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

StyleSimulations.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

StyleSimulations.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

StyleSimulations.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

StyleSimulations.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

StyleSimulations.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

StyleSimulations.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

StyleSimulations.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

StyleSimulations.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

StyleSimulations.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

TextDecorations = function(TextDecorationsXamlElement) 
{
        /// <summary>Describes the possible text decorations.</summary>
        /// <param name="TextDecorationsXamlElement">Non strongly typed Xaml Element</param>
        this.element = TextDecorationsXamlElement;
}
TextDecorations.get_None = function()
{
    /// <returns type="TextDecorations" />
    return Convert.ToTextDecorations("None");
}

TextDecorations.is_None = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="TextDecorations" />
    return valueToCompare.element == "None";
}

TextDecorations.get_Underline = function()
{
    /// <returns type="TextDecorations" />
    return Convert.ToTextDecorations("Underline");
}

TextDecorations.is_Underline = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="TextDecorations" />
    return valueToCompare.element == "Underline";
}

TextDecorations.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

TextDecorations.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

TextDecorations.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

TextDecorations.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

TextDecorations.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

TextDecorations.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

TextDecorations.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

TextDecorations.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

TextDecorations.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

TextDecorations.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

FontStretches = function(FontStretchesXamlElement) 
{
        /// <summary></summary>
        /// <param name="FontStretchesXamlElement">Non strongly typed Xaml Element</param>
        this.element = FontStretchesXamlElement;
}
FontStretches.get_UltraCondensed = function()
{
    /// <returns type="FontStretches" />
    return Convert.ToFontStretches("UltraCondensed");
}

FontStretches.is_UltraCondensed = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontStretches" />
    return valueToCompare.element == "UltraCondensed";
}

FontStretches.get_ExtraCondensed = function()
{
    /// <returns type="FontStretches" />
    return Convert.ToFontStretches("ExtraCondensed");
}

FontStretches.is_ExtraCondensed = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontStretches" />
    return valueToCompare.element == "ExtraCondensed";
}

FontStretches.get_Condensed = function()
{
    /// <returns type="FontStretches" />
    return Convert.ToFontStretches("Condensed");
}

FontStretches.is_Condensed = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontStretches" />
    return valueToCompare.element == "Condensed";
}

FontStretches.get_SemiCondensed = function()
{
    /// <returns type="FontStretches" />
    return Convert.ToFontStretches("SemiCondensed");
}

FontStretches.is_SemiCondensed = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontStretches" />
    return valueToCompare.element == "SemiCondensed";
}

FontStretches.get_Normal = function()
{
    /// <returns type="FontStretches" />
    return Convert.ToFontStretches("Normal");
}

FontStretches.is_Normal = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontStretches" />
    return valueToCompare.element == "Normal";
}

FontStretches.get_Medium = function()
{
    /// <returns type="FontStretches" />
    return Convert.ToFontStretches("Medium");
}

FontStretches.is_Medium = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontStretches" />
    return valueToCompare.element == "Medium";
}

FontStretches.get_SemiExpanded = function()
{
    /// <returns type="FontStretches" />
    return Convert.ToFontStretches("SemiExpanded");
}

FontStretches.is_SemiExpanded = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontStretches" />
    return valueToCompare.element == "SemiExpanded";
}

FontStretches.get_Expanded = function()
{
    /// <returns type="FontStretches" />
    return Convert.ToFontStretches("Expanded");
}

FontStretches.is_Expanded = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontStretches" />
    return valueToCompare.element == "Expanded";
}

FontStretches.get_ExtraExpanded = function()
{
    /// <returns type="FontStretches" />
    return Convert.ToFontStretches("ExtraExpanded");
}

FontStretches.is_ExtraExpanded = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontStretches" />
    return valueToCompare.element == "ExtraExpanded";
}

FontStretches.get_UltraExpanded = function()
{
    /// <returns type="FontStretches" />
    return Convert.ToFontStretches("UltraExpanded");
}

FontStretches.is_UltraExpanded = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FontStretches" />
    return valueToCompare.element == "UltraExpanded";
}

FontStretches.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

FontStretches.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

FontStretches.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

FontStretches.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

FontStretches.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

FontStretches.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

FontStretches.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

FontStretches.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

FontStretches.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

FontStretches.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

Visibility = function(VisibilityXamlElement) 
{
        /// <summary>Specifies the display state of an element.</summary>
        /// <param name="VisibilityXamlElement">Non strongly typed Xaml Element</param>
        this.element = VisibilityXamlElement;
}
Visibility.get_Visible = function()
{
    /// <returns type="Visibility" />
    return Convert.ToVisibility("Visible");
}

Visibility.is_Visible = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="Visibility" />
    return valueToCompare.element == "Visible";
}

Visibility.get_Collapsed = function()
{
    /// <returns type="Visibility" />
    return Convert.ToVisibility("Collapsed");
}

Visibility.is_Collapsed = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="Visibility" />
    return valueToCompare.element == "Collapsed";
}

Visibility.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

Visibility.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

Visibility.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

Visibility.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

Visibility.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

Visibility.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

Visibility.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

Visibility.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

Visibility.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

Visibility.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

ErrorType = function(ErrorTypeXamlElement) 
{
        /// <summary>Describes the possible types of errors.</summary>
        /// <param name="ErrorTypeXamlElement">Non strongly typed Xaml Element</param>
        this.element = ErrorTypeXamlElement;
}
ErrorType.get_NoError = function()
{
    /// <returns type="ErrorType" />
    return Convert.ToErrorType("NoError");
}

ErrorType.is_NoError = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="ErrorType" />
    return valueToCompare.element == "NoError";
}

ErrorType.get_UnknownError = function()
{
    /// <returns type="ErrorType" />
    return Convert.ToErrorType("UnknownError");
}

ErrorType.is_UnknownError = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="ErrorType" />
    return valueToCompare.element == "UnknownError";
}

ErrorType.get_InitializeError = function()
{
    /// <returns type="ErrorType" />
    return Convert.ToErrorType("InitializeError");
}

ErrorType.is_InitializeError = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="ErrorType" />
    return valueToCompare.element == "InitializeError";
}

ErrorType.get_ParserError = function()
{
    /// <returns type="ErrorType" />
    return Convert.ToErrorType("ParserError");
}

ErrorType.is_ParserError = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="ErrorType" />
    return valueToCompare.element == "ParserError";
}

ErrorType.get_ObjectModelError = function()
{
    /// <returns type="ErrorType" />
    return Convert.ToErrorType("ObjectModelError");
}

ErrorType.is_ObjectModelError = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="ErrorType" />
    return valueToCompare.element == "ObjectModelError";
}

ErrorType.get_RuntimeError = function()
{
    /// <returns type="ErrorType" />
    return Convert.ToErrorType("RuntimeError");
}

ErrorType.is_RuntimeError = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="ErrorType" />
    return valueToCompare.element == "RuntimeError";
}

ErrorType.get_DownloadError = function()
{
    /// <returns type="ErrorType" />
    return Convert.ToErrorType("DownloadError");
}

ErrorType.is_DownloadError = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="ErrorType" />
    return valueToCompare.element == "DownloadError";
}

ErrorType.get_MediaError = function()
{
    /// <returns type="ErrorType" />
    return Convert.ToErrorType("MediaError");
}

ErrorType.is_MediaError = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="ErrorType" />
    return valueToCompare.element == "MediaError";
}

ErrorType.get_ImageError = function()
{
    /// <returns type="ErrorType" />
    return Convert.ToErrorType("ImageError");
}

ErrorType.is_ImageError = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="ErrorType" />
    return valueToCompare.element == "ImageError";
}

ErrorType.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

ErrorType.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

ErrorType.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

ErrorType.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

ErrorType.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

ErrorType.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

ErrorType.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

ErrorType.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

ErrorType.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

ErrorType.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

DependencyObject = function(DependencyObjectXamlElement) 
{
        /// <summary>Provides Silverlight property system services.</summary>
        /// <param name="DependencyObjectXamlElement">Non strongly typed Xaml Element</param>
        this.element = DependencyObjectXamlElement;
}
DependencyObject.createFromXaml = function(Host)
{
    /// <returns type="DependencyObject" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new DependencyObject(Host.content.createFromXaml("<DependencyObject />"));
    } catch (ex) {}
    if (Host.getHost)
        return DependencyObject.CreateNew(Host.getHost());
    return;
}
DependencyObject.get_NameProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("DependencyObject.Name");
}

DependencyObject.prototype.get_name = function()
{
    /// <summary>Gets or sets a unique identification for the object.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.name);
}

DependencyObject.prototype.setValue = function(property, obj)
{
     /// <summary>Sets the specified property or event to the specified value.</summary>
    /// <param name="property" type="DependencyProperty" integer="False" >The name of the dependency property to set.</param>   
    /// <param name="obj" type="T" integer="False" ></param>   
    TypeSafety({"DependencyProperty":property, "T":obj});
    return (this.element.setValue(property.element, obj));
}

DependencyObject.prototype.findName = function(name)
{
     /// <summary>Gets any object in the Silverlight object hierarchy by referencing the object's x:Name attribute value.</summary>
    /// <param name="name" type="String" integer="False" >The name of the object to get.</param>   
    /// <returns type="DependencyObject" integer="False" />   
    TypeSafety({"String":name});
    return Convert.ToDependencyObject(this.element.findName(name));
}

DependencyObject.prototype.getValue = function(property)
{
     /// <summary>Gets the value of the specified property.</summary>
    /// <param name="property" type="DependencyProperty" integer="False" >The property to get the value of.</param>   
    /// <returns type="Object" integer="False" />   
    TypeSafety({"DependencyProperty":property});
    return (this.element.getValue(property.element));
}

DependencyObject.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

DependencyObject.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

DependencyObject.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

DependencyObject.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

DependencyObject.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

Visual = function(VisualXamlElement) 
{
        /// <summary></summary>
        /// <param name="VisualXamlElement">Non strongly typed Xaml Element</param>
        this.element = VisualXamlElement;
}
Visual.createFromXaml = function(Host)
{
    /// <returns type="Visual" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Visual(Host.content.createFromXaml("<Visual />"));
    } catch (ex) {}
    if (Host.getHost)
        return Visual.CreateNew(Host.getHost());
    return;
}
Visual.prototype = new DependencyObject;

Visual.prototype.captureMouse = function()
{
     /// <summary>Enables mouse capture for the object.</summary>
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({});
    return (this.element.captureMouse());
}

Visual.prototype.releaseMouseCapture = function()
{
     /// <summary>Disables mouse capture for the object.</summary>
    TypeSafety({});
    return (this.element.releaseMouseCapture());
}

UIElement = function(UIElementXamlElement) 
{
        /// <summary>UIElement is the base class for rendered objects. This class is abstract.</summary>
        /// <param name="UIElementXamlElement">Non strongly typed Xaml Element</param>
        this.element = UIElementXamlElement;
}
UIElement.createFromXaml = function(Host)
{
    /// <returns type="UIElement" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new UIElement(Host.content.createFromXaml("<UIElement />"));
    } catch (ex) {}
    if (Host.getHost)
        return UIElement.CreateNew(Host.getHost());
    return;
}
UIElement.get_OpacityProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("UIElement.Opacity");
}

UIElement.get_ClipProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("UIElement.Clip");
}

UIElement.get_RenderTransformProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("UIElement.RenderTransform");
}

UIElement.get_TriggersProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("UIElement.Triggers");
}

UIElement.get_OpacityMaskProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("UIElement.OpacityMask");
}

UIElement.get_RenderTransformOriginProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("UIElement.RenderTransformOrigin");
}

UIElement.get_CursorProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("UIElement.Cursor");
}

UIElement.get_IsHitTestVisibleProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("UIElement.IsHitTestVisible");
}

UIElement.get_VisibilityProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("UIElement.Visibility");
}

UIElement.get_ResourcesProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("UIElement.Resources");
}

UIElement.get_TagProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("UIElement.Tag");
}

UIElement.get_ZIndexProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("UIElement.ZIndex");
}

UIElement.prototype = new Visual;

UIElement.prototype.set_opacity = function(value)
{
    /// <summary>Gets or sets the degree of opacity of a Brush.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.opacity = value;
}

UIElement.prototype.get_opacity = function()
{
    /// <summary>Gets or sets the degree of opacity of a Brush.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.opacity);
}

UIElement.prototype.set_clip = function(value)
{
    /// <summary>Gets or sets the Geometry used to define the outline of the contents of an element.</summary>
    /// <param name="value" type="Geometry" integer="False" />
    TypeSafety({"Geometry" : value});   
    this.element.clip = value.element;
}

UIElement.prototype.get_clip = function()
{
    /// <summary>Gets or sets the Geometry used to define the outline of the contents of an element.</summary>
    /// <returns type="Geometry" integer="False" />   
    return Convert.ToGeometry(this.element.clip);
}

UIElement.prototype.set_renderTransform = function(value)
{
    /// <summary>Gets or sets transform information that affects the rendering position of this object.</summary>
    /// <param name="value" type="Transform" integer="False" />
    TypeSafety({"Transform" : value});   
    this.element.renderTransform = value.element;
}

UIElement.prototype.get_renderTransform = function()
{
    /// <summary>Gets or sets transform information that affects the rendering position of this object.</summary>
    /// <returns type="Transform" integer="False" />   
    return Convert.ToTransform(this.element.renderTransform);
}

UIElement.prototype.set_triggers = function(value)
{
    /// <summary>Gets the collection of triggers established directly on this element, or in child elements.</summary>
    /// <param name="value" type="TriggerCollection" integer="False" />
    TypeSafety({"TriggerCollection" : value});   
    this.element.triggers = value.element;
}

UIElement.prototype.get_triggers = function()
{
    /// <summary>Gets the collection of triggers established directly on this element, or in child elements.</summary>
    /// <returns type="TriggerCollection" integer="False" />   
    return Convert.ToTriggerCollection(this.element.triggers);
}

UIElement.prototype.set_opacityMask = function(value)
{
    /// <summary>Gets or sets the brush used to alter the opacity of select regions of this object.</summary>
    /// <param name="value" type="Brush" integer="False" />
    TypeSafety({"Brush" : value});   
    this.element.opacityMask = value.element;
}

UIElement.prototype.get_opacityMask = function()
{
    /// <summary>Gets or sets the brush used to alter the opacity of select regions of this object.</summary>
    /// <returns type="Brush" integer="False" />   
    return Convert.ToBrush(this.element.opacityMask);
}

UIElement.prototype.set_renderTransformOrigin = function(value)
{
    /// <summary>Gets or sets the center point of any possible render transform declared by RenderTransform, relative to the bounds of the element.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.renderTransformOrigin = value.element;
}

UIElement.prototype.get_renderTransformOrigin = function()
{
    /// <summary>Gets or sets the center point of any possible render transform declared by RenderTransform, relative to the bounds of the element.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.renderTransformOrigin);
}

UIElement.prototype.set_cursor = function(value)
{
    /// <summary>Gets or sets the cursor that displays when the mouse pointer is over the element.</summary>
    /// <param name="value" type="Cursors" integer="False" />
    TypeSafety({"Cursors" : value});   
    this.element.cursor = value.element;
}

UIElement.prototype.get_cursor = function()
{
    /// <summary>Gets or sets the cursor that displays when the mouse pointer is over the element.</summary>
    /// <returns type="Cursors" integer="False" />   
    return Convert.ToCursors(this.element.cursor);
}

UIElement.prototype.set_isHitTestVisible = function(value)
{
    /// <summary>Gets or sets whether the contained area of this UIElement can be used for hit-testing.</summary>
    /// <param name="value" type="Boolean" integer="False" />
    TypeSafety({"Boolean" : value});   
    this.element.isHitTestVisible = value;
}

UIElement.prototype.get_isHitTestVisible = function()
{
    /// <summary>Gets or sets whether the contained area of this UIElement can be used for hit-testing.</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.isHitTestVisible);
}

UIElement.prototype.set_visibility = function(value)
{
    /// <summary>Gets or sets the user interface (UI) visibility of this element.</summary>
    /// <param name="value" type="Visibility" integer="False" />
    TypeSafety({"Visibility" : value});   
    this.element.visibility = value.element;
}

UIElement.prototype.get_visibility = function()
{
    /// <summary>Gets or sets the user interface (UI) visibility of this element.</summary>
    /// <returns type="Visibility" integer="False" />   
    return Convert.ToVisibility(this.element.visibility);
}

UIElement.prototype.set_resources = function(value)
{
    /// <summary>Gets or sets a collection of Storyboard objects that you can use to control animations.</summary>
    /// <param name="value" type="ResourceDictionary" integer="False" />
    TypeSafety({"ResourceDictionary" : value});   
    this.element.resources = value.element;
}

UIElement.prototype.get_resources = function()
{
    /// <summary>Gets or sets a collection of Storyboard objects that you can use to control animations.</summary>
    /// <returns type="ResourceDictionary" integer="False" />   
    return Convert.ToResourceDictionary(this.element.resources);
}

UIElement.prototype.set_tag = function(value)
{
    /// <summary>Gets or sets an object that can be used for user storage or information passing.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.tag = value;
}

UIElement.prototype.get_tag = function()
{
    /// <summary>Gets or sets an object that can be used for user storage or information passing.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.tag);
}

UIElement.prototype.add_Loaded = function(handler) {
    /// <summary>Fired when the Silverlight content is loaded into the host Silverlight plugin and parsed, but before the content is rendered.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("Loaded", handler);
}
    
UIElement.prototype.remove_Loaded = function(eventId) {
    /// <summary>Fired when the Silverlight content is loaded into the host Silverlight plugin and parsed, but before the content is rendered.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_UIElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("Loaded", eventId);
}

UIElement.prototype.add_MouseMove = function(handler) {
    /// <summary>Occurs when the coordinate position of the mouse changes.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("MouseMove", handler);
}
    
UIElement.prototype.remove_MouseMove = function(eventId) {
    /// <summary>Occurs when the coordinate position of the mouse changes.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_UIElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("MouseMove", eventId);
}

UIElement.prototype.add_MouseEnter = function(handler) {
    /// <summary>Occurs when the mouse enters the bounding area of an object.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("MouseEnter", handler);
}
    
UIElement.prototype.remove_MouseEnter = function(eventId) {
    /// <summary>Occurs when the mouse enters the bounding area of an object.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_UIElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("MouseEnter", eventId);
}

UIElement.prototype.add_MouseLeave = function(handler) {
    /// <summary>Occurs when the mouse leaves the bounding area of an object.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("MouseLeave", handler);
}
    
UIElement.prototype.remove_MouseLeave = function(eventId) {
    /// <summary>Occurs when the mouse leaves the bounding area of an object.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_UIElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("MouseLeave", eventId);
}

UIElement.prototype.add_MouseLeftButtonDown = function(handler) {
    /// <summary>Occurs when the left mouse button is depressed.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("MouseLeftButtonDown", handler);
}
    
UIElement.prototype.remove_MouseLeftButtonDown = function(eventId) {
    /// <summary>Occurs when the left mouse button is depressed.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_UIElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("MouseLeftButtonDown", eventId);
}

UIElement.prototype.add_MouseLeftButtonUp = function(handler) {
    /// <summary>Occurs when the left mouse button is released.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("MouseLeftButtonUp", handler);
}
    
UIElement.prototype.remove_MouseLeftButtonUp = function(eventId) {
    /// <summary>Occurs when the left mouse button is released.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_UIElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("MouseLeftButtonUp", eventId);
}

UIElement.prototype.add_KeyUp = function(handler) {
    /// <summary>Occurs when the key is released while the plugin has focus.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("KeyUp", handler);
}
    
UIElement.prototype.remove_KeyUp = function(eventId) {
    /// <summary>Occurs when the key is released while the plugin has focus.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_UIElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("KeyUp", eventId);
}

UIElement.prototype.add_KeyDown = function(handler) {
    /// <summary>Occurs when the key is pressed while the content has focus.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("KeyDown", handler);
}
    
UIElement.prototype.remove_KeyDown = function(eventId) {
    /// <summary>Occurs when the key is pressed while the content has focus.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_UIElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("KeyDown", eventId);
}

UIElement.prototype.add_GotFocus = function(handler) {
    /// <summary>Occurs when an object receives focus.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("GotFocus", handler);
}
    
UIElement.prototype.remove_GotFocus = function(eventId) {
    /// <summary>Occurs when an object receives focus.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_UIElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("GotFocus", eventId);
}

UIElement.prototype.add_LostFocus = function(handler) {
    /// <summary>Occurs when an object loses focus.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("LostFocus", handler);
}
    
UIElement.prototype.remove_LostFocus = function(eventId) {
    /// <summary>Occurs when an object loses focus.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_UIElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("LostFocus", eventId);
}

UIElement.prototype.getHost = function()
{
    /// <returns type="Host" />
    return new Host(this.element.getHost());
}

FrameworkElement = function(FrameworkElementXamlElement) 
{
        /// <summary></summary>
        /// <param name="FrameworkElementXamlElement">Non strongly typed Xaml Element</param>
        this.element = FrameworkElementXamlElement;
}
FrameworkElement.createFromXaml = function(Host)
{
    /// <returns type="FrameworkElement" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new FrameworkElement(Host.content.createFromXaml("<FrameworkElement />"));
    } catch (ex) {}
    if (Host.getHost)
        return FrameworkElement.CreateNew(Host.getHost());
    return;
}
FrameworkElement.get_WidthProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("FrameworkElement.Width");
}

FrameworkElement.get_HeightProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("FrameworkElement.Height");
}

FrameworkElement.prototype = new UIElement;

FrameworkElement.prototype.set_width = function(value)
{
    /// <summary>The width of the associated stroke.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.width = value;
}

FrameworkElement.prototype.get_width = function()
{
    /// <summary>The width of the associated stroke.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.width);
}

FrameworkElement.prototype.set_height = function(value)
{
    /// <summary>The height of the associated stroke.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.height = value;
}

FrameworkElement.prototype.get_height = function()
{
    /// <summary>The height of the associated stroke.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.height);
}

FrameworkElement.prototype.get_parent = function()
{
    /// <summary></summary>
    /// <returns type="Object" integer="False" />   
    return (this.element.parent);
}

Collection = function(CollectionXamlElement) 
{
        /// <summary>Represents a collection of objects.</summary>
        /// <param name="CollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = CollectionXamlElement;
}
Collection.createFromXaml = function(Host)
{
    /// <returns type="Collection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Collection(Host.content.createFromXaml("<Collection />"));
    } catch (ex) {}
    if (Host.getHost)
        return Collection.CreateNew(Host.getHost());
    return;
}
Collection.get_CountProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Collection.Count");
}

Collection.prototype = new DependencyObject;

Collection.prototype.get_isFixedSize = function()
{
    /// <summary></summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.isFixedSize);
}

Collection.prototype.get_isReadOnly = function()
{
    /// <summary></summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.isReadOnly);
}

Collection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="T" integer="False" />   
    return (this.element.getItem(Index));
}

Collection.prototype.get_count = function()
{
    /// <summary>Gets the number of items contained in the collection.</summary>
    /// <returns type="Number" integer="True" />   
    return (this.element.count);
}

Collection.prototype.get_isSynchronized = function()
{
    /// <summary></summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.isSynchronized);
}

Collection.prototype.get_syncRoot = function()
{
    /// <summary></summary>
    /// <returns type="Object" integer="False" />   
    return (this.element.syncRoot);
}

Collection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="T" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"T":value});
    return (this.element.add(value));
}

Collection.prototype.clear = function()
{
     /// <summary>Removes all objects from the collection.</summary>
    TypeSafety({});
    return (this.element.clear());
}

Collection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="T" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"T":value});
    return (this.element.contains(value));
}

Collection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="T" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"T":value});
    return (this.element.indexOf(value));
}

Collection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="T" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "T":value});
    return (this.element.insert(index, value));
}

Collection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="T" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"T":value});
    return (this.element.remove(value));
}

Collection.prototype.removeAt = function(index)
{
     /// <summary>Removes the object at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The zero-based index of the object to remove.</param>   
    TypeSafety({"Number":index});
    return (this.element.removeAt(index));
}

Collection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="T[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"T[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

Collection.prototype.getEnumerator = function()
{
     /// <summary></summary>
    /// <returns type="IEnumerator`1" integer="False" />   
    TypeSafety({});
    return (this.element.getEnumerator());
}

Collection.prototype.printContents = function()
{
     /// <summary></summary>
    TypeSafety({});
    return (this.element.printContents());
}

Inlines = function(InlinesXamlElement) 
{
        /// <summary></summary>
        /// <param name="InlinesXamlElement">Non strongly typed Xaml Element</param>
        this.element = InlinesXamlElement;
}
Inlines.createFromXaml = function(Host)
{
    /// <returns type="Inlines" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Inlines(Host.content.createFromXaml("<Inlines />"));
    } catch (ex) {}
    if (Host.getHost)
        return Inlines.CreateNew(Host.getHost());
    return;
}
Inlines.prototype = new Collection;

Inlines.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="Inline" integer="False" />   
    return Convert.ToInline(this.element.getItem(Index));
}

Inlines.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="Inline" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"Inline":value});
    return (this.element.add(value.element));
}

Inlines.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="Inline" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Inline":value});
    return (this.element.contains(value.element));
}

Inlines.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="Inline" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Inline":value});
    return (this.element.indexOf(value.element));
}

Inlines.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="Inline" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "Inline":value});
    return (this.element.insert(index, value.element));
}

Inlines.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="Inline" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Inline":value});
    return (this.element.remove(value.element));
}

Inlines.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="Inline[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"Inline[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

TriggerCollection = function(TriggerCollectionXamlElement) 
{
        /// <summary>Represents a collection of Trigger objects.</summary>
        /// <param name="TriggerCollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = TriggerCollectionXamlElement;
}
TriggerCollection.createFromXaml = function(Host)
{
    /// <returns type="TriggerCollection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new TriggerCollection(Host.content.createFromXaml("<TriggerCollection />"));
    } catch (ex) {}
    if (Host.getHost)
        return TriggerCollection.CreateNew(Host.getHost());
    return;
}
TriggerCollection.prototype = new Collection;

TriggerCollection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="EventTrigger" integer="False" />   
    return Convert.ToEventTrigger(this.element.getItem(Index));
}

TriggerCollection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="EventTrigger" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"EventTrigger":value});
    return (this.element.add(value.element));
}

TriggerCollection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="EventTrigger" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"EventTrigger":value});
    return (this.element.contains(value.element));
}

TriggerCollection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="EventTrigger" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"EventTrigger":value});
    return (this.element.indexOf(value.element));
}

TriggerCollection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="EventTrigger" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "EventTrigger":value});
    return (this.element.insert(index, value.element));
}

TriggerCollection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="EventTrigger" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"EventTrigger":value});
    return (this.element.remove(value.element));
}

TriggerCollection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="EventTrigger[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"EventTrigger[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

EventTrigger = function(EventTriggerXamlElement) 
{
        /// <summary>Represents a trigger that applies a set of actions in response to an event.</summary>
        /// <param name="EventTriggerXamlElement">Non strongly typed Xaml Element</param>
        this.element = EventTriggerXamlElement;
}
EventTrigger.createFromXaml = function(Host)
{
    /// <returns type="EventTrigger" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new EventTrigger(Host.content.createFromXaml("<EventTrigger />"));
    } catch (ex) {}
    if (Host.getHost)
        return EventTrigger.CreateNew(Host.getHost());
    return;
}
EventTrigger.get_RoutedEventProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("EventTrigger.RoutedEvent");
}

EventTrigger.get_ActionsProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("EventTrigger.Actions");
}

EventTrigger.prototype = new DependencyObject;

EventTrigger.prototype.set_routedEvent = function(value)
{
    /// <summary>Gets or sets the object type and RoutedEvent that will activate this trigger. Only the Loaded event is supported.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.routedEvent = value;
}

EventTrigger.prototype.get_routedEvent = function()
{
    /// <summary>Gets or sets the object type and RoutedEvent that will activate this trigger. Only the Loaded event is supported.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.routedEvent);
}

EventTrigger.prototype.set_actions = function(value)
{
    /// <summary>Gets the collection of actions to apply when the event occurs.</summary>
    /// <param name="value" type="TriggerActionCollection" integer="False" />
    TypeSafety({"TriggerActionCollection" : value});   
    this.element.actions = value.element;
}

EventTrigger.prototype.get_actions = function()
{
    /// <summary>Gets the collection of actions to apply when the event occurs.</summary>
    /// <returns type="TriggerActionCollection" integer="False" />   
    return Convert.ToTriggerActionCollection(this.element.actions);
}

TriggerActionCollection = function(TriggerActionCollectionXamlElement) 
{
        /// <summary>Represents a collection of TriggerAction objects that can be individually accessed by index.</summary>
        /// <param name="TriggerActionCollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = TriggerActionCollectionXamlElement;
}
TriggerActionCollection.createFromXaml = function(Host)
{
    /// <returns type="TriggerActionCollection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new TriggerActionCollection(Host.content.createFromXaml("<TriggerActionCollection />"));
    } catch (ex) {}
    if (Host.getHost)
        return TriggerActionCollection.CreateNew(Host.getHost());
    return;
}
TriggerActionCollection.prototype = new Collection;

TriggerActionCollection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="BeginStoryboard" integer="False" />   
    return Convert.ToBeginStoryboard(this.element.getItem(Index));
}

TriggerActionCollection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="BeginStoryboard" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"BeginStoryboard":value});
    return (this.element.add(value.element));
}

TriggerActionCollection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="BeginStoryboard" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"BeginStoryboard":value});
    return (this.element.contains(value.element));
}

TriggerActionCollection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="BeginStoryboard" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"BeginStoryboard":value});
    return (this.element.indexOf(value.element));
}

TriggerActionCollection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="BeginStoryboard" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "BeginStoryboard":value});
    return (this.element.insert(index, value.element));
}

TriggerActionCollection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="BeginStoryboard" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"BeginStoryboard":value});
    return (this.element.remove(value.element));
}

TriggerActionCollection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="BeginStoryboard[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"BeginStoryboard[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

ErrorEventArgs = function(ErrorEventArgsXamlElement) 
{
        /// <summary>Provides data for the onError event.</summary>
        /// <param name="ErrorEventArgsXamlElement">Non strongly typed Xaml Element</param>
        this.element = ErrorEventArgsXamlElement;
}
ErrorEventArgs.prototype.set_errorMessage = function(value)
{
    /// <summary>Gets the error description associated with the error.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.errorMessage = value;
}

ErrorEventArgs.prototype.get_errorMessage = function()
{
    /// <summary>Gets the error description associated with the error.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.errorMessage);
}

ErrorEventArgs.prototype.set_errorCode = function(value)
{
    /// <summary>Gets the error code associted witht he error.</summary>
    /// <param name="value" type="Number" integer="True" />
    TypeSafety({"Number" : value});   
    this.element.errorCode = value;
}

ErrorEventArgs.prototype.get_errorCode = function()
{
    /// <summary>Gets the error code associted witht he error.</summary>
    /// <returns type="Number" integer="True" />   
    return (this.element.errorCode);
}

ErrorEventArgs.prototype.set_errorType = function(value)
{
    /// <summary>Gets the ErrorType of the error associated with the event.</summary>
    /// <param name="value" type="ErrorType" integer="False" />
    TypeSafety({"ErrorType" : value});   
    this.element.errorType = value.element;
}

ErrorEventArgs.prototype.get_errorType = function()
{
    /// <summary>Gets the ErrorType of the error associated with the event.</summary>
    /// <returns type="ErrorType" integer="False" />   
    return Convert.ToErrorType(this.element.errorType);
}

ErrorEventArgs.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

ErrorEventArgs.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

ErrorEventArgs.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

ErrorEventArgs.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

ErrorEventArgs.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

ParserErrorEventArgs = function(ParserErrorEventArgsXamlElement) 
{
        /// <summary>Provides data for XAML parser error events.</summary>
        /// <param name="ParserErrorEventArgsXamlElement">Non strongly typed Xaml Element</param>
        this.element = ParserErrorEventArgsXamlElement;
}
ParserErrorEventArgs.prototype = new ErrorEventArgs;

ParserErrorEventArgs.prototype.set_xamlFile = function(value)
{
    /// <summary>Gets the name of the Xaml file that the parser error occurred in.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.xamlFile = value;
}

ParserErrorEventArgs.prototype.get_xamlFile = function()
{
    /// <summary>Gets the name of the Xaml file that the parser error occurred in.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.xamlFile);
}

ParserErrorEventArgs.prototype.set_lineNumber = function(value)
{
    /// <summary>Gets the line number at which the parser error occurred.</summary>
    /// <param name="value" type="Number" integer="True" />
    TypeSafety({"Number" : value});   
    this.element.lineNumber = value;
}

ParserErrorEventArgs.prototype.get_lineNumber = function()
{
    /// <summary>Gets the line number at which the parser error occurred.</summary>
    /// <returns type="Number" integer="True" />   
    return (this.element.lineNumber);
}

ParserErrorEventArgs.prototype.set_charPosition = function(value)
{
    /// <summary>The character position within the line that the parser error occurred on.</summary>
    /// <param name="value" type="Number" integer="True" />
    TypeSafety({"Number" : value});   
    this.element.charPosition = value;
}

ParserErrorEventArgs.prototype.get_charPosition = function()
{
    /// <summary>The character position within the line that the parser error occurred on.</summary>
    /// <returns type="Number" integer="True" />   
    return (this.element.charPosition);
}

ParserErrorEventArgs.prototype.set_xmlElement = function(value)
{
    /// <summary>Gets the xml element that the parser error occurred in.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.xmlElement = value;
}

ParserErrorEventArgs.prototype.get_xmlElement = function()
{
    /// <summary>Gets the xml element that the parser error occurred in.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.xmlElement);
}

ParserErrorEventArgs.prototype.set_xmlAttribute = function(value)
{
    /// <summary>Gets the xml attribute that the parser error occurred in.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.xmlAttribute = value;
}

ParserErrorEventArgs.prototype.get_xmlAttribute = function()
{
    /// <summary>Gets the xml attribute that the parser error occurred in.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.xmlAttribute);
}

RuntimeErrorEventArgs = function(RuntimeErrorEventArgsXamlElement) 
{
        /// <summary>Provides data for runtime error events.</summary>
        /// <param name="RuntimeErrorEventArgsXamlElement">Non strongly typed Xaml Element</param>
        this.element = RuntimeErrorEventArgsXamlElement;
}
RuntimeErrorEventArgs.prototype = new ErrorEventArgs;

RuntimeErrorEventArgs.prototype.set_methodName = function(value)
{
    /// <summary>Gets the name of the method associated with the runtime error.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.methodName = value;
}

RuntimeErrorEventArgs.prototype.get_methodName = function()
{
    /// <summary>Gets the name of the method associated with the runtime error.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.methodName);
}

RuntimeErrorEventArgs.prototype.set_lineNumber = function(value)
{
    /// <summary>Gets the line number at which the parser error occurred.</summary>
    /// <param name="value" type="Number" integer="True" />
    TypeSafety({"Number" : value});   
    this.element.lineNumber = value;
}

RuntimeErrorEventArgs.prototype.get_lineNumber = function()
{
    /// <summary>Gets the line number at which the parser error occurred.</summary>
    /// <returns type="Number" integer="True" />   
    return (this.element.lineNumber);
}

RuntimeErrorEventArgs.prototype.set_charPosition = function(value)
{
    /// <summary>The character position within the line that the parser error occurred on.</summary>
    /// <param name="value" type="Number" integer="True" />
    TypeSafety({"Number" : value});   
    this.element.charPosition = value;
}

RuntimeErrorEventArgs.prototype.get_charPosition = function()
{
    /// <summary>The character position within the line that the parser error occurred on.</summary>
    /// <returns type="Number" integer="True" />   
    return (this.element.charPosition);
}

Downloader = function(DownloaderXamlElement) 
{
        /// <summary>Represents the set of download functionality for a Silverlight plugin. The downloader can asynchronously download any content that can be obtained through an HTTP GET request.</summary>
        /// <param name="DownloaderXamlElement">Non strongly typed Xaml Element</param>
        this.element = DownloaderXamlElement;
}
Downloader.createFromXaml = function(Host)
{
    /// <returns type="Downloader" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Downloader(Host.content.createFromXaml("<Downloader />"));
    } catch (ex) {}
    if (Host.getHost)
        return Downloader.CreateNew(Host.getHost());
    return;
}
Downloader.get_DownloadProgressProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Downloader.DownloadProgress");
}

Downloader.get_ResponseTextProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Downloader.ResponseText");
}

Downloader.get_StatusProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Downloader.Status");
}

Downloader.get_StatusTextProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Downloader.StatusText");
}

Downloader.get_UriProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Downloader.Uri");
}

Downloader.prototype = new DependencyObject;

Downloader.prototype.set_downloadProgress = function(value)
{
    /// <summary>Gets a value that indicates the percentage of downloaded content.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.downloadProgress = value;
}

Downloader.prototype.get_downloadProgress = function()
{
    /// <summary>Gets a value that indicates the percentage of downloaded content.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.downloadProgress);
}

Downloader.prototype.set_responseText = function(value)
{
    /// <summary>Gets downloaded data from a successful download request.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.responseText = value;
}

Downloader.prototype.get_responseText = function()
{
    /// <summary>Gets downloaded data from a successful download request.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.responseText);
}

Downloader.prototype.set_status = function(value)
{
    /// <summary>Gets the current status of the Downloader object request.</summary>
    /// <param name="value" type="Number" integer="True" />
    TypeSafety({"Number" : value});   
    this.element.status = value;
}

Downloader.prototype.get_status = function()
{
    /// <summary>Gets the current status of the Downloader object request.</summary>
    /// <returns type="Number" integer="True" />   
    return (this.element.status);
}

Downloader.prototype.set_statusText = function(value)
{
    /// <summary>Gets the current status of the Downloader object request.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.statusText = value;
}

Downloader.prototype.get_statusText = function()
{
    /// <summary>Gets the current status of the Downloader object request.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.statusText);
}

Downloader.prototype.set_uri = function(value)
{
    /// <summary>Gets the Uniform Resource Identifier (URI) of the download request.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.uri = value;
}

Downloader.prototype.get_uri = function()
{
    /// <summary>Gets the Uniform Resource Identifier (URI) of the download request.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.uri);
}

Downloader.prototype.send = function()
{
     /// <summary>Executes a download request.</summary>
    TypeSafety({});
    return (this.element.send());
}

Downloader.prototype.abort = function()
{
     /// <summary>Cancels the downloader request and resets properties to their initial state.</summary>
    TypeSafety({});
    return (this.element.abort());
}

Downloader.prototype.getResponseText = function(PartName)
{
     /// <summary>Retrieves a specified part of packaged downloaded data.</summary>
    /// <param name="PartName" type="String" integer="False" >The name of the specific part of the downloaded content package.</param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":PartName});
    return (this.element.getResponseText(PartName));
}

Downloader.prototype.open = function(verb, URI)
{
     /// <summary>Initializes the download request.</summary>
    /// <param name="verb" type="String" integer="False" >The type of download action. The only supported action is "GET".</param>   
    /// <param name="URI" type="String" integer="False" >The Uniform Resource Identifier (URI) of the content to perform the download action.</param>   
    TypeSafety({"String":verb, "String":URI});
    return (this.element.open(verb, URI));
}

Downloader.prototype.add_DownloadProgressChanged = function(handler) {
    /// <summary>Occurs while content is being downloaded during a download request.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("DownloadProgressChanged", handler);
}
    
Downloader.prototype.remove_DownloadProgressChanged = function(eventId) {
    /// <summary>Occurs while content is being downloaded during a download request.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_Downloader</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("DownloadProgressChanged", eventId);
}

Downloader.prototype.add_Completed = function(handler) {
    /// <summary>Occurs when a download request completes with content.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("Completed", handler);
}
    
Downloader.prototype.remove_Completed = function(eventId) {
    /// <summary>Occurs when a download request completes with content.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_Downloader</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("Completed", eventId);
}

Downloader.prototype.add_DownloadFailed = function(handler) {
    /// <summary>Occurs when an attempted download request completes with no content.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("DownloadFailed", handler);
}
    
Downloader.prototype.remove_DownloadFailed = function(eventId) {
    /// <summary>Occurs when an attempted download request completes with no content.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_Downloader</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("DownloadFailed", eventId);
}

ResourceDictionary = function(ResourceDictionaryXamlElement) 
{
        /// <summary>Represents a collection of Resource objects.</summary>
        /// <param name="ResourceDictionaryXamlElement">Non strongly typed Xaml Element</param>
        this.element = ResourceDictionaryXamlElement;
}
ResourceDictionary.createFromXaml = function(Host)
{
    /// <returns type="ResourceDictionary" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new ResourceDictionary(Host.content.createFromXaml("<ResourceDictionary />"));
    } catch (ex) {}
    if (Host.getHost)
        return ResourceDictionary.CreateNew(Host.getHost());
    return;
}
ResourceDictionary.prototype = new Collection;

ResourceDictionary.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="DependencyObject" integer="False" />   
    return Convert.ToDependencyObject(this.element.getItem(Index));
}

ResourceDictionary.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="DependencyObject" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"DependencyObject":value});
    return (this.element.add(value.element));
}

ResourceDictionary.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="DependencyObject" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"DependencyObject":value});
    return (this.element.contains(value.element));
}

ResourceDictionary.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="DependencyObject" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"DependencyObject":value});
    return (this.element.indexOf(value.element));
}

ResourceDictionary.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="DependencyObject" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "DependencyObject":value});
    return (this.element.insert(index, value.element));
}

ResourceDictionary.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="DependencyObject" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"DependencyObject":value});
    return (this.element.remove(value.element));
}

ResourceDictionary.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="DependencyObject[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"DependencyObject[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

Stroke = function(StrokeXamlElement) 
{
        /// <summary>Represents a collection of points that correspond to a stylus-down, move, and stylus-up sequence.</summary>
        /// <param name="StrokeXamlElement">Non strongly typed Xaml Element</param>
        this.element = StrokeXamlElement;
}
Stroke.createFromXaml = function(Host)
{
    /// <returns type="Stroke" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Stroke(Host.content.createFromXaml("<Stroke />"));
    } catch (ex) {}
    if (Host.getHost)
        return Stroke.CreateNew(Host.getHost());
    return;
}
Stroke.get_StylusPointsProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Stroke.StylusPoints");
}

Stroke.get_DrawingAttributesProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Stroke.DrawingAttributes");
}

Stroke.prototype = new DependencyObject;

Stroke.prototype.set_stylusPoints = function(value)
{
    /// <summary>The collection of StylusPoint objects that make up the Stroke.</summary>
    /// <param name="value" type="StylusPointCollection" integer="False" />
    TypeSafety({"StylusPointCollection" : value});   
    this.element.stylusPoints = value.element;
}

Stroke.prototype.get_stylusPoints = function()
{
    /// <summary>The collection of StylusPoint objects that make up the Stroke.</summary>
    /// <returns type="StylusPointCollection" integer="False" />   
    return Convert.ToStylusPointCollection(this.element.stylusPoints);
}

Stroke.prototype.set_drawingAttributes = function(value)
{
    /// <summary>Specifies the appearance of the Stroke.</summary>
    /// <param name="value" type="DrawingAttributes" integer="False" />
    TypeSafety({"DrawingAttributes" : value});   
    this.element.drawingAttributes = value.element;
}

Stroke.prototype.get_drawingAttributes = function()
{
    /// <summary>Specifies the appearance of the Stroke.</summary>
    /// <returns type="DrawingAttributes" integer="False" />   
    return Convert.ToDrawingAttributes(this.element.drawingAttributes);
}

Stroke.prototype.getBounds = function()
{
     /// <summary>Returns a Rect which is the bounding box of the strokes in the collection.</summary>
    /// <returns type="Rect" integer="False" />   
    TypeSafety({});
    return Convert.ToRect(this.element.getBounds());
}

Stroke.prototype.hitTest = function(stylusPointCollection)
{
     /// <summary></summary>
    /// <param name="stylusPointCollection" type="StylusPointCollection" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"StylusPointCollection":stylusPointCollection});
    return (this.element.hitTest(stylusPointCollection.element));
}

StrokeCollection = function(StrokeCollectionXamlElement) 
{
        /// <summary>Represents zero or more Stroke objects that are grouped together.</summary>
        /// <param name="StrokeCollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = StrokeCollectionXamlElement;
}
StrokeCollection.createFromXaml = function(Host)
{
    /// <returns type="StrokeCollection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new StrokeCollection(Host.content.createFromXaml("<StrokeCollection />"));
    } catch (ex) {}
    if (Host.getHost)
        return StrokeCollection.CreateNew(Host.getHost());
    return;
}
StrokeCollection.prototype = new Collection;

StrokeCollection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="Stroke" integer="False" />   
    return Convert.ToStroke(this.element.getItem(Index));
}

StrokeCollection.prototype.getBounds = function()
{
     /// <summary>Returns a Rect which is the bounding box of the strokes in the collection.</summary>
    /// <returns type="Rect" integer="False" />   
    TypeSafety({});
    return Convert.ToRect(this.element.getBounds());
}

StrokeCollection.prototype.hitTest = function(stylusPointCollection)
{
     /// <summary></summary>
    /// <param name="stylusPointCollection" type="StylusPointCollection" integer="False" ></param>   
    /// <returns type="StrokeCollection" integer="False" />   
    TypeSafety({"StylusPointCollection":stylusPointCollection});
    return Convert.ToStrokeCollection(this.element.hitTest(stylusPointCollection.element));
}

StrokeCollection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="Stroke" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"Stroke":value});
    return (this.element.add(value.element));
}

StrokeCollection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="Stroke" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Stroke":value});
    return (this.element.contains(value.element));
}

StrokeCollection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="Stroke" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Stroke":value});
    return (this.element.indexOf(value.element));
}

StrokeCollection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="Stroke" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "Stroke":value});
    return (this.element.insert(index, value.element));
}

StrokeCollection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="Stroke" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Stroke":value});
    return (this.element.remove(value.element));
}

StrokeCollection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="Stroke[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"Stroke[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

DrawingAttributes = function(DrawingAttributesXamlElement) 
{
        /// <summary>Represents the appearance of a Stroke.</summary>
        /// <param name="DrawingAttributesXamlElement">Non strongly typed Xaml Element</param>
        this.element = DrawingAttributesXamlElement;
}
DrawingAttributes.createFromXaml = function(Host)
{
    /// <returns type="DrawingAttributes" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new DrawingAttributes(Host.content.createFromXaml("<DrawingAttributes />"));
    } catch (ex) {}
    if (Host.getHost)
        return DrawingAttributes.CreateNew(Host.getHost());
    return;
}
DrawingAttributes.get_ColorProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("DrawingAttributes.Color");
}

DrawingAttributes.get_OutlineColorProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("DrawingAttributes.OutlineColor");
}

DrawingAttributes.get_WidthProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("DrawingAttributes.Width");
}

DrawingAttributes.get_HeightProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("DrawingAttributes.Height");
}

DrawingAttributes.prototype = new DependencyObject;

DrawingAttributes.prototype.set_color = function(value)
{
    /// <summary>The color of the associated stroke.</summary>
    /// <param name="value" type="Color" integer="False" />
    TypeSafety({"Color" : value});   
    this.element.color = value.element;
}

DrawingAttributes.prototype.get_color = function()
{
    /// <summary>The color of the associated stroke.</summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.color);
}

DrawingAttributes.prototype.set_outlineColor = function(value)
{
    /// <summary>The outline color of the associated stroke.</summary>
    /// <param name="value" type="Color" integer="False" />
    TypeSafety({"Color" : value});   
    this.element.outlineColor = value.element;
}

DrawingAttributes.prototype.get_outlineColor = function()
{
    /// <summary>The outline color of the associated stroke.</summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.outlineColor);
}

DrawingAttributes.prototype.set_width = function(value)
{
    /// <summary>The width of the associated stroke.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.width = value;
}

DrawingAttributes.prototype.get_width = function()
{
    /// <summary>The width of the associated stroke.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.width);
}

DrawingAttributes.prototype.set_height = function(value)
{
    /// <summary>The height of the associated stroke.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.height = value;
}

DrawingAttributes.prototype.get_height = function()
{
    /// <summary>The height of the associated stroke.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.height);
}

FillRule = function(FillRuleXamlElement) 
{
        /// <summary>Specifies how the intersecting areas of PathFigure objects contained in a Geometry are combined to form the area of the Geometry.</summary>
        /// <param name="FillRuleXamlElement">Non strongly typed Xaml Element</param>
        this.element = FillRuleXamlElement;
}
FillRule.get_EvenOdd = function()
{
    /// <returns type="FillRule" />
    return Convert.ToFillRule("EvenOdd");
}

FillRule.is_EvenOdd = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FillRule" />
    return valueToCompare.element == "EvenOdd";
}

FillRule.get_Nonzero = function()
{
    /// <returns type="FillRule" />
    return Convert.ToFillRule("Nonzero");
}

FillRule.is_Nonzero = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FillRule" />
    return valueToCompare.element == "Nonzero";
}

FillRule.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

FillRule.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

FillRule.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

FillRule.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

FillRule.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

FillRule.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

FillRule.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

FillRule.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

FillRule.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

FillRule.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

SweepDirection = function(SweepDirectionXamlElement) 
{
        /// <summary>Defines the direction an elliptical arc is drawn.</summary>
        /// <param name="SweepDirectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = SweepDirectionXamlElement;
}
SweepDirection.get_Counterclockwise = function()
{
    /// <returns type="SweepDirection" />
    return Convert.ToSweepDirection("Counterclockwise");
}

SweepDirection.is_Counterclockwise = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="SweepDirection" />
    return valueToCompare.element == "Counterclockwise";
}

SweepDirection.get_Clockwise = function()
{
    /// <returns type="SweepDirection" />
    return Convert.ToSweepDirection("Clockwise");
}

SweepDirection.is_Clockwise = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="SweepDirection" />
    return valueToCompare.element == "Clockwise";
}

SweepDirection.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

SweepDirection.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

SweepDirection.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

SweepDirection.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

SweepDirection.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

SweepDirection.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

SweepDirection.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

SweepDirection.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

SweepDirection.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

SweepDirection.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

GradientSpreadMethod = function(GradientSpreadMethodXamlElement) 
{
        /// <summary>Specifies how to draw the gradient outside a gradient brush's gradient vector or space.</summary>
        /// <param name="GradientSpreadMethodXamlElement">Non strongly typed Xaml Element</param>
        this.element = GradientSpreadMethodXamlElement;
}
GradientSpreadMethod.get_Pad = function()
{
    /// <returns type="GradientSpreadMethod" />
    return Convert.ToGradientSpreadMethod("Pad");
}

GradientSpreadMethod.is_Pad = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="GradientSpreadMethod" />
    return valueToCompare.element == "Pad";
}

GradientSpreadMethod.get_Reflect = function()
{
    /// <returns type="GradientSpreadMethod" />
    return Convert.ToGradientSpreadMethod("Reflect");
}

GradientSpreadMethod.is_Reflect = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="GradientSpreadMethod" />
    return valueToCompare.element == "Reflect";
}

GradientSpreadMethod.get_Repeat = function()
{
    /// <returns type="GradientSpreadMethod" />
    return Convert.ToGradientSpreadMethod("Repeat");
}

GradientSpreadMethod.is_Repeat = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="GradientSpreadMethod" />
    return valueToCompare.element == "Repeat";
}

GradientSpreadMethod.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

GradientSpreadMethod.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

GradientSpreadMethod.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

GradientSpreadMethod.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

GradientSpreadMethod.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

GradientSpreadMethod.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

GradientSpreadMethod.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

GradientSpreadMethod.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

GradientSpreadMethod.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

GradientSpreadMethod.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

ColorInterpolationMode = function(ColorInterpolationModeXamlElement) 
{
        /// <summary>Determines how the colors in a gradient are interpolated.</summary>
        /// <param name="ColorInterpolationModeXamlElement">Non strongly typed Xaml Element</param>
        this.element = ColorInterpolationModeXamlElement;
}
ColorInterpolationMode.get_ScRgbLinearInterpolation = function()
{
    /// <returns type="ColorInterpolationMode" />
    return Convert.ToColorInterpolationMode("ScRgbLinearInterpolation");
}

ColorInterpolationMode.is_ScRgbLinearInterpolation = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="ColorInterpolationMode" />
    return valueToCompare.element == "ScRgbLinearInterpolation";
}

ColorInterpolationMode.get_SRgbLinearInterpolation = function()
{
    /// <returns type="ColorInterpolationMode" />
    return Convert.ToColorInterpolationMode("SRgbLinearInterpolation");
}

ColorInterpolationMode.is_SRgbLinearInterpolation = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="ColorInterpolationMode" />
    return valueToCompare.element == "SRgbLinearInterpolation";
}

ColorInterpolationMode.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

ColorInterpolationMode.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

ColorInterpolationMode.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

ColorInterpolationMode.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

ColorInterpolationMode.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

ColorInterpolationMode.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

ColorInterpolationMode.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

ColorInterpolationMode.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

ColorInterpolationMode.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

ColorInterpolationMode.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

BrushMappingMode = function(BrushMappingModeXamlElement) 
{
        /// <summary>Specifies the coordinate system used by a Brush.</summary>
        /// <param name="BrushMappingModeXamlElement">Non strongly typed Xaml Element</param>
        this.element = BrushMappingModeXamlElement;
}
BrushMappingMode.get_Absolute = function()
{
    /// <returns type="BrushMappingMode" />
    return Convert.ToBrushMappingMode("Absolute");
}

BrushMappingMode.is_Absolute = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="BrushMappingMode" />
    return valueToCompare.element == "Absolute";
}

BrushMappingMode.get_RelativeToBoundingBox = function()
{
    /// <returns type="BrushMappingMode" />
    return Convert.ToBrushMappingMode("RelativeToBoundingBox");
}

BrushMappingMode.is_RelativeToBoundingBox = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="BrushMappingMode" />
    return valueToCompare.element == "RelativeToBoundingBox";
}

BrushMappingMode.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

BrushMappingMode.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

BrushMappingMode.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

BrushMappingMode.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

BrushMappingMode.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

BrushMappingMode.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

BrushMappingMode.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

BrushMappingMode.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

BrushMappingMode.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

BrushMappingMode.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

AlignmentX = function(AlignmentXXamlElement) 
{
        /// <summary>Describes how content is positioned horizontally in a container.</summary>
        /// <param name="AlignmentXXamlElement">Non strongly typed Xaml Element</param>
        this.element = AlignmentXXamlElement;
}
AlignmentX.get_Left = function()
{
    /// <returns type="AlignmentX" />
    return Convert.ToAlignmentX("Left");
}

AlignmentX.is_Left = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="AlignmentX" />
    return valueToCompare.element == "Left";
}

AlignmentX.get_Center = function()
{
    /// <returns type="AlignmentX" />
    return Convert.ToAlignmentX("Center");
}

AlignmentX.is_Center = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="AlignmentX" />
    return valueToCompare.element == "Center";
}

AlignmentX.get_Right = function()
{
    /// <returns type="AlignmentX" />
    return Convert.ToAlignmentX("Right");
}

AlignmentX.is_Right = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="AlignmentX" />
    return valueToCompare.element == "Right";
}

AlignmentX.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

AlignmentX.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

AlignmentX.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

AlignmentX.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

AlignmentX.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

AlignmentX.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

AlignmentX.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

AlignmentX.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

AlignmentX.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

AlignmentX.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

AlignmentY = function(AlignmentYXamlElement) 
{
        /// <summary>Describes how content is positioned vertically in a container.</summary>
        /// <param name="AlignmentYXamlElement">Non strongly typed Xaml Element</param>
        this.element = AlignmentYXamlElement;
}
AlignmentY.get_Top = function()
{
    /// <returns type="AlignmentY" />
    return Convert.ToAlignmentY("Top");
}

AlignmentY.is_Top = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="AlignmentY" />
    return valueToCompare.element == "Top";
}

AlignmentY.get_Center = function()
{
    /// <returns type="AlignmentY" />
    return Convert.ToAlignmentY("Center");
}

AlignmentY.is_Center = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="AlignmentY" />
    return valueToCompare.element == "Center";
}

AlignmentY.get_Bottom = function()
{
    /// <returns type="AlignmentY" />
    return Convert.ToAlignmentY("Bottom");
}

AlignmentY.is_Bottom = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="AlignmentY" />
    return valueToCompare.element == "Bottom";
}

AlignmentY.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

AlignmentY.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

AlignmentY.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

AlignmentY.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

AlignmentY.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

AlignmentY.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

AlignmentY.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

AlignmentY.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

AlignmentY.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

AlignmentY.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

Stretch = function(StretchXamlElement) 
{
        /// <summary>Describes how content is resized to fill its allocated space.</summary>
        /// <param name="StretchXamlElement">Non strongly typed Xaml Element</param>
        this.element = StretchXamlElement;
}
Stretch.get_None = function()
{
    /// <returns type="Stretch" />
    return Convert.ToStretch("None");
}

Stretch.is_None = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="Stretch" />
    return valueToCompare.element == "None";
}

Stretch.get_Fill = function()
{
    /// <returns type="Stretch" />
    return Convert.ToStretch("Fill");
}

Stretch.is_Fill = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="Stretch" />
    return valueToCompare.element == "Fill";
}

Stretch.get_Uniform = function()
{
    /// <returns type="Stretch" />
    return Convert.ToStretch("Uniform");
}

Stretch.is_Uniform = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="Stretch" />
    return valueToCompare.element == "Uniform";
}

Stretch.get_UniformToFill = function()
{
    /// <returns type="Stretch" />
    return Convert.ToStretch("UniformToFill");
}

Stretch.is_UniformToFill = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="Stretch" />
    return valueToCompare.element == "UniformToFill";
}

Stretch.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

Stretch.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

Stretch.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

Stretch.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

Stretch.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

Stretch.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

Stretch.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

Stretch.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

Stretch.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

Stretch.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

PenLineCap = function(PenLineCapXamlElement) 
{
        /// <summary>Describes the shape at the end of a line or segment.</summary>
        /// <param name="PenLineCapXamlElement">Non strongly typed Xaml Element</param>
        this.element = PenLineCapXamlElement;
}
PenLineCap.get_Flat = function()
{
    /// <returns type="PenLineCap" />
    return Convert.ToPenLineCap("Flat");
}

PenLineCap.is_Flat = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="PenLineCap" />
    return valueToCompare.element == "Flat";
}

PenLineCap.get_Square = function()
{
    /// <returns type="PenLineCap" />
    return Convert.ToPenLineCap("Square");
}

PenLineCap.is_Square = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="PenLineCap" />
    return valueToCompare.element == "Square";
}

PenLineCap.get_Round = function()
{
    /// <returns type="PenLineCap" />
    return Convert.ToPenLineCap("Round");
}

PenLineCap.is_Round = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="PenLineCap" />
    return valueToCompare.element == "Round";
}

PenLineCap.get_Triangle = function()
{
    /// <returns type="PenLineCap" />
    return Convert.ToPenLineCap("Triangle");
}

PenLineCap.is_Triangle = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="PenLineCap" />
    return valueToCompare.element == "Triangle";
}

PenLineCap.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

PenLineCap.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

PenLineCap.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

PenLineCap.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

PenLineCap.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

PenLineCap.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

PenLineCap.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

PenLineCap.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

PenLineCap.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

PenLineCap.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

PenLineJoin = function(PenLineJoinXamlElement) 
{
        /// <summary>Describes the shape that joins two lines or segments.</summary>
        /// <param name="PenLineJoinXamlElement">Non strongly typed Xaml Element</param>
        this.element = PenLineJoinXamlElement;
}
PenLineJoin.get_Miter = function()
{
    /// <returns type="PenLineJoin" />
    return Convert.ToPenLineJoin("Miter");
}

PenLineJoin.is_Miter = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="PenLineJoin" />
    return valueToCompare.element == "Miter";
}

PenLineJoin.get_Bevel = function()
{
    /// <returns type="PenLineJoin" />
    return Convert.ToPenLineJoin("Bevel");
}

PenLineJoin.is_Bevel = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="PenLineJoin" />
    return valueToCompare.element == "Bevel";
}

PenLineJoin.get_Round = function()
{
    /// <returns type="PenLineJoin" />
    return Convert.ToPenLineJoin("Round");
}

PenLineJoin.is_Round = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="PenLineJoin" />
    return valueToCompare.element == "Round";
}

PenLineJoin.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

PenLineJoin.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

PenLineJoin.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

PenLineJoin.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

PenLineJoin.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

PenLineJoin.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

PenLineJoin.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

PenLineJoin.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

PenLineJoin.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

PenLineJoin.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

Transform = function(TransformXamlElement) 
{
        /// <summary>Defines functionality that enables transformations in a 2-D plane. Transformations include rotation (RotateTransform), scale (ScaleTransform), skew (SkewTransform), and translation (TranslateTransform).</summary>
        /// <param name="TransformXamlElement">Non strongly typed Xaml Element</param>
        this.element = TransformXamlElement;
}
Transform.createFromXaml = function(Host)
{
    /// <returns type="Transform" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Transform(Host.content.createFromXaml("<Transform />"));
    } catch (ex) {}
    if (Host.getHost)
        return Transform.CreateNew(Host.getHost());
    return;
}
Transform.prototype = new DependencyObject;

PathSegment = function(PathSegmentXamlElement) 
{
        /// <summary>Represents a segment of a PathFigure object.</summary>
        /// <param name="PathSegmentXamlElement">Non strongly typed Xaml Element</param>
        this.element = PathSegmentXamlElement;
}
PathSegment.createFromXaml = function(Host)
{
    /// <returns type="PathSegment" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new PathSegment(Host.content.createFromXaml("<PathSegment />"));
    } catch (ex) {}
    if (Host.getHost)
        return PathSegment.CreateNew(Host.getHost());
    return;
}
PathSegment.prototype = new DependencyObject;

Brush = function(BrushXamlElement) 
{
        /// <summary>Defines objects used to paint graphical objects.</summary>
        /// <param name="BrushXamlElement">Non strongly typed Xaml Element</param>
        this.element = BrushXamlElement;
}
Brush.createFromXaml = function(Host)
{
    /// <returns type="Brush" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Brush(Host.content.createFromXaml("<Brush />"));
    } catch (ex) {}
    if (Host.getHost)
        return Brush.CreateNew(Host.getHost());
    return;
}
Brush.get_OpacityProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Brush.Opacity");
}

Brush.get_TransformProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Brush.Transform");
}

Brush.get_RelativeTransformProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Brush.RelativeTransform");
}

Brush.prototype = new DependencyObject;

Brush.prototype.set_opacity = function(value)
{
    /// <summary>Gets or sets the degree of opacity of a Brush.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.opacity = value;
}

Brush.prototype.get_opacity = function()
{
    /// <summary>Gets or sets the degree of opacity of a Brush.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.opacity);
}

Brush.prototype.set_transform = function(value)
{
    /// <summary>Gets or sets the transformation that is applied to the brush using relative coordinates.</summary>
    /// <param name="value" type="Transform" integer="False" />
    TypeSafety({"Transform" : value});   
    this.element.transform = value.element;
}

Brush.prototype.get_transform = function()
{
    /// <summary>Gets or sets the transformation that is applied to the brush using relative coordinates.</summary>
    /// <returns type="Transform" integer="False" />   
    return Convert.ToTransform(this.element.transform);
}

Brush.prototype.set_relativeTransform = function(value)
{
    /// <summary>Gets or sets the transformation that is applied to the brush using relative coordinates.</summary>
    /// <param name="value" type="Transform" integer="False" />
    TypeSafety({"Transform" : value});   
    this.element.relativeTransform = value.element;
}

Brush.prototype.get_relativeTransform = function()
{
    /// <summary>Gets or sets the transformation that is applied to the brush using relative coordinates.</summary>
    /// <returns type="Transform" integer="False" />   
    return Convert.ToTransform(this.element.relativeTransform);
}

TileBrush = function(TileBrushXamlElement) 
{
        /// <summary></summary>
        /// <param name="TileBrushXamlElement">Non strongly typed Xaml Element</param>
        this.element = TileBrushXamlElement;
}
TileBrush.createFromXaml = function(Host)
{
    /// <returns type="TileBrush" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new TileBrush(Host.content.createFromXaml("<TileBrush />"));
    } catch (ex) {}
    if (Host.getHost)
        return TileBrush.CreateNew(Host.getHost());
    return;
}
TileBrush.get_AlignmentXProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TileBrush.AlignmentX");
}

TileBrush.get_AlignmentYProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TileBrush.AlignmentY");
}

TileBrush.get_StretchProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TileBrush.Stretch");
}

TileBrush.prototype = new Brush;

TileBrush.prototype.set_alignmentX = function(value)
{
    /// <summary>Gets or sets the horizontal alignment of images in the ImageBrush.</summary>
    /// <param name="value" type="AlignmentX" integer="False" />
    TypeSafety({"AlignmentX" : value});   
    this.element.alignmentX = value.element;
}

TileBrush.prototype.get_alignmentX = function()
{
    /// <summary>Gets or sets the horizontal alignment of images in the ImageBrush.</summary>
    /// <returns type="AlignmentX" integer="False" />   
    return Convert.ToAlignmentX(this.element.alignmentX);
}

TileBrush.prototype.set_alignmentY = function(value)
{
    /// <summary>Gets or sets the vertical alignment of images in the ImageBrush.</summary>
    /// <param name="value" type="AlignmentY" integer="False" />
    TypeSafety({"AlignmentY" : value});   
    this.element.alignmentY = value.element;
}

TileBrush.prototype.get_alignmentY = function()
{
    /// <summary>Gets or sets the vertical alignment of images in the ImageBrush.</summary>
    /// <returns type="AlignmentY" integer="False" />   
    return Convert.ToAlignmentY(this.element.alignmentY);
}

TileBrush.prototype.set_stretch = function(value)
{
    /// <summary>Gets or sets a value that specifies how the content of this brush stretches.</summary>
    /// <param name="value" type="Stretch" integer="False" />
    TypeSafety({"Stretch" : value});   
    this.element.stretch = value.element;
}

TileBrush.prototype.get_stretch = function()
{
    /// <summary>Gets or sets a value that specifies how the content of this brush stretches.</summary>
    /// <returns type="Stretch" integer="False" />   
    return Convert.ToStretch(this.element.stretch);
}

Geometry = function(GeometryXamlElement) 
{
        /// <summary>Classes that derive from this abstract base class define geometric shapes. Geometry objects can be used for clipping, hit-testing, and rendering 2-D graphic data.</summary>
        /// <param name="GeometryXamlElement">Non strongly typed Xaml Element</param>
        this.element = GeometryXamlElement;
}
Geometry.createFromXaml = function(Host)
{
    /// <returns type="Geometry" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Geometry(Host.content.createFromXaml("<Geometry />"));
    } catch (ex) {}
    if (Host.getHost)
        return Geometry.CreateNew(Host.getHost());
    return;
}
Geometry.get_FillRuleProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Geometry.FillRule");
}

Geometry.get_TransformProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Geometry.Transform");
}

Geometry.prototype = new DependencyObject;

Geometry.prototype.set_fillRule = function(value)
{
    /// <summary>Gets or sets a value that determines how the intersecting areas (PathFigures) contained in this PathGeometry are combined.</summary>
    /// <param name="value" type="FillRule" integer="False" />
    TypeSafety({"FillRule" : value});   
    this.element.fillRule = value.element;
}

Geometry.prototype.get_fillRule = function()
{
    /// <summary>Gets or sets a value that determines how the intersecting areas (PathFigures) contained in this PathGeometry are combined.</summary>
    /// <returns type="FillRule" integer="False" />   
    return Convert.ToFillRule(this.element.fillRule);
}

Geometry.prototype.set_transform = function(value)
{
    /// <summary>Gets or sets the transformation that is applied to the brush using relative coordinates.</summary>
    /// <param name="value" type="Transform" integer="False" />
    TypeSafety({"Transform" : value});   
    this.element.transform = value.element;
}

Geometry.prototype.get_transform = function()
{
    /// <summary>Gets or sets the transformation that is applied to the brush using relative coordinates.</summary>
    /// <returns type="Transform" integer="False" />   
    return Convert.ToTransform(this.element.transform);
}

RotateTransform = function(RotateTransformXamlElement) 
{
        /// <summary>Rotates an object clockwise about a specified point in a 2-D x-y coordinate system.</summary>
        /// <param name="RotateTransformXamlElement">Non strongly typed Xaml Element</param>
        this.element = RotateTransformXamlElement;
}
RotateTransform.createFromXaml = function(Host)
{
    /// <returns type="RotateTransform" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new RotateTransform(Host.content.createFromXaml("<RotateTransform />"));
    } catch (ex) {}
    if (Host.getHost)
        return RotateTransform.CreateNew(Host.getHost());
    return;
}
RotateTransform.get_CenterXProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("RotateTransform.CenterX");
}

RotateTransform.get_CenterYProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("RotateTransform.CenterY");
}

RotateTransform.get_AngleProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("RotateTransform.Angle");
}

RotateTransform.prototype = new Transform;

RotateTransform.prototype.set_centerX = function(value)
{
    /// <summary>Gets or sets the x-coordinate of the rotation center point.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.centerX = value;
}

RotateTransform.prototype.get_centerX = function()
{
    /// <summary>Gets or sets the x-coordinate of the rotation center point.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.centerX);
}

RotateTransform.prototype.set_centerY = function(value)
{
    /// <summary>Gets or sets the y-coordinate of the rotation center point.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.centerY = value;
}

RotateTransform.prototype.get_centerY = function()
{
    /// <summary>Gets or sets the y-coordinate of the rotation center point.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.centerY);
}

RotateTransform.prototype.set_angle = function(value)
{
    /// <summary>Gets or sets the amount (in degrees) by which the ellipse is rotated about the x-axis.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.angle = value;
}

RotateTransform.prototype.get_angle = function()
{
    /// <summary>Gets or sets the amount (in degrees) by which the ellipse is rotated about the x-axis.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.angle);
}

ScaleTransform = function(ScaleTransformXamlElement) 
{
        /// <summary>Scales an object in the 2-D x-y coordinate system.</summary>
        /// <param name="ScaleTransformXamlElement">Non strongly typed Xaml Element</param>
        this.element = ScaleTransformXamlElement;
}
ScaleTransform.createFromXaml = function(Host)
{
    /// <returns type="ScaleTransform" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new ScaleTransform(Host.content.createFromXaml("<ScaleTransform />"));
    } catch (ex) {}
    if (Host.getHost)
        return ScaleTransform.CreateNew(Host.getHost());
    return;
}
ScaleTransform.get_CenterXProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ScaleTransform.CenterX");
}

ScaleTransform.get_CenterYProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ScaleTransform.CenterY");
}

ScaleTransform.get_ScaleXProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ScaleTransform.ScaleX");
}

ScaleTransform.get_ScaleYProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ScaleTransform.ScaleY");
}

ScaleTransform.prototype = new Transform;

ScaleTransform.prototype.set_centerX = function(value)
{
    /// <summary>Gets or sets the x-coordinate of the rotation center point.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.centerX = value;
}

ScaleTransform.prototype.get_centerX = function()
{
    /// <summary>Gets or sets the x-coordinate of the rotation center point.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.centerX);
}

ScaleTransform.prototype.set_centerY = function(value)
{
    /// <summary>Gets or sets the y-coordinate of the rotation center point.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.centerY = value;
}

ScaleTransform.prototype.get_centerY = function()
{
    /// <summary>Gets or sets the y-coordinate of the rotation center point.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.centerY);
}

ScaleTransform.prototype.set_scaleX = function(value)
{
    /// <summary>Gets or sets the x-axis scale factor.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.scaleX = value;
}

ScaleTransform.prototype.get_scaleX = function()
{
    /// <summary>Gets or sets the x-axis scale factor.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.scaleX);
}

ScaleTransform.prototype.set_scaleY = function(value)
{
    /// <summary>Gets or sets the y-axis scale factor.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.scaleY = value;
}

ScaleTransform.prototype.get_scaleY = function()
{
    /// <summary>Gets or sets the y-axis scale factor.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.scaleY);
}

SkewTransform = function(SkewTransformXamlElement) 
{
        /// <summary>Represents a 2-D skew.</summary>
        /// <param name="SkewTransformXamlElement">Non strongly typed Xaml Element</param>
        this.element = SkewTransformXamlElement;
}
SkewTransform.createFromXaml = function(Host)
{
    /// <returns type="SkewTransform" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new SkewTransform(Host.content.createFromXaml("<SkewTransform />"));
    } catch (ex) {}
    if (Host.getHost)
        return SkewTransform.CreateNew(Host.getHost());
    return;
}
SkewTransform.get_CenterXProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("SkewTransform.CenterX");
}

SkewTransform.get_CenterYProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("SkewTransform.CenterY");
}

SkewTransform.get_AngleXProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("SkewTransform.AngleX");
}

SkewTransform.get_AngleYProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("SkewTransform.AngleY");
}

SkewTransform.prototype = new Transform;

SkewTransform.prototype.set_centerX = function(value)
{
    /// <summary>Gets or sets the x-coordinate of the rotation center point.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.centerX = value;
}

SkewTransform.prototype.get_centerX = function()
{
    /// <summary>Gets or sets the x-coordinate of the rotation center point.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.centerX);
}

SkewTransform.prototype.set_centerY = function(value)
{
    /// <summary>Gets or sets the y-coordinate of the rotation center point.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.centerY = value;
}

SkewTransform.prototype.get_centerY = function()
{
    /// <summary>Gets or sets the y-coordinate of the rotation center point.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.centerY);
}

SkewTransform.prototype.set_angleX = function(value)
{
    /// <summary>Gets or sets the x-axis skew angle, which is measured in degrees counterclockwise from the y-axis.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.angleX = value;
}

SkewTransform.prototype.get_angleX = function()
{
    /// <summary>Gets or sets the x-axis skew angle, which is measured in degrees counterclockwise from the y-axis.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.angleX);
}

SkewTransform.prototype.set_angleY = function(value)
{
    /// <summary>Gets or sets the y-axis skew angle, which is measured in degrees counterclockwise from the x-axis.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.angleY = value;
}

SkewTransform.prototype.get_angleY = function()
{
    /// <summary>Gets or sets the y-axis skew angle, which is measured in degrees counterclockwise from the x-axis.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.angleY);
}

TranslateTransform = function(TranslateTransformXamlElement) 
{
        /// <summary>Translates (moves) an object in the 2-D x-y coordinate system.</summary>
        /// <param name="TranslateTransformXamlElement">Non strongly typed Xaml Element</param>
        this.element = TranslateTransformXamlElement;
}
TranslateTransform.createFromXaml = function(Host)
{
    /// <returns type="TranslateTransform" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new TranslateTransform(Host.content.createFromXaml("<TranslateTransform />"));
    } catch (ex) {}
    if (Host.getHost)
        return TranslateTransform.CreateNew(Host.getHost());
    return;
}
TranslateTransform.get_XProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TranslateTransform.X");
}

TranslateTransform.get_YProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TranslateTransform.Y");
}

TranslateTransform.prototype = new Transform;

TranslateTransform.prototype.set_x = function(value)
{
    /// <summary>Gets or sets the x-radius value of the EllipseGeometry.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.x = value;
}

TranslateTransform.prototype.get_x = function()
{
    /// <summary>Gets or sets the x-radius value of the EllipseGeometry.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.x);
}

TranslateTransform.prototype.set_y = function(value)
{
    /// <summary>Gets or sets the total amount by which the animation changes its starting value.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.y = value;
}

TranslateTransform.prototype.get_y = function()
{
    /// <summary>Gets or sets the total amount by which the animation changes its starting value.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.y);
}

TransformCollection = function(TransformCollectionXamlElement) 
{
        /// <summary>Represents a collection of Transform objects that can be individually accessed by index.</summary>
        /// <param name="TransformCollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = TransformCollectionXamlElement;
}
TransformCollection.createFromXaml = function(Host)
{
    /// <returns type="TransformCollection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new TransformCollection(Host.content.createFromXaml("<TransformCollection />"));
    } catch (ex) {}
    if (Host.getHost)
        return TransformCollection.CreateNew(Host.getHost());
    return;
}
TransformCollection.prototype = new Collection;

TransformCollection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="Transform" integer="False" />   
    return Convert.ToTransform(this.element.getItem(Index));
}

TransformCollection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="Transform" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"Transform":value});
    return (this.element.add(value.element));
}

TransformCollection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="Transform" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Transform":value});
    return (this.element.contains(value.element));
}

TransformCollection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="Transform" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Transform":value});
    return (this.element.indexOf(value.element));
}

TransformCollection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="Transform" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "Transform":value});
    return (this.element.insert(index, value.element));
}

TransformCollection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="Transform" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Transform":value});
    return (this.element.remove(value.element));
}

TransformCollection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="Transform[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"Transform[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

TransformGroup = function(TransformGroupXamlElement) 
{
        /// <summary>Represents a composite Transform composed of other Transform objects.</summary>
        /// <param name="TransformGroupXamlElement">Non strongly typed Xaml Element</param>
        this.element = TransformGroupXamlElement;
}
TransformGroup.createFromXaml = function(Host)
{
    /// <returns type="TransformGroup" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new TransformGroup(Host.content.createFromXaml("<TransformGroup />"));
    } catch (ex) {}
    if (Host.getHost)
        return TransformGroup.CreateNew(Host.getHost());
    return;
}
TransformGroup.get_ChildrenProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TransformGroup.Children");
}

TransformGroup.prototype = new Transform;

TransformGroup.prototype.set_children = function(value)
{
    /// <summary>Gets or sets the collection of child elements on the Canvas.</summary>
    /// <param name="value" type="TransformCollection" integer="False" />
    TypeSafety({"TransformCollection" : value});   
    this.element.children = value.element;
}

TransformGroup.prototype.get_children = function()
{
    /// <summary>Gets or sets the collection of child elements on the Canvas.</summary>
    /// <returns type="TransformCollection" integer="False" />   
    return Convert.ToTransformCollection(this.element.children);
}

MatrixTransform = function(MatrixTransformXamlElement) 
{
        /// <summary>Creates an arbitrary affine matrix transformation that is used to manipulate objects or coordinate systems in a 2-D plane.</summary>
        /// <param name="MatrixTransformXamlElement">Non strongly typed Xaml Element</param>
        this.element = MatrixTransformXamlElement;
}
MatrixTransform.createFromXaml = function(Host)
{
    /// <returns type="MatrixTransform" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new MatrixTransform(Host.content.createFromXaml("<MatrixTransform />"));
    } catch (ex) {}
    if (Host.getHost)
        return MatrixTransform.CreateNew(Host.getHost());
    return;
}
MatrixTransform.get_MatrixProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MatrixTransform.Matrix");
}

MatrixTransform.prototype = new Transform;

MatrixTransform.prototype.set_matrix = function(value)
{
    /// <summary>Gets or sets the Matrix structure that defines this transformation.</summary>
    /// <param name="value" type="Matrix" integer="False" />
    TypeSafety({"Matrix" : value});   
    this.element.matrix = value.element;
}

MatrixTransform.prototype.get_matrix = function()
{
    /// <summary>Gets or sets the Matrix structure that defines this transformation.</summary>
    /// <returns type="Matrix" integer="False" />   
    return Convert.ToMatrix(this.element.matrix);
}

LineSegment = function(LineSegmentXamlElement) 
{
        /// <summary>Represents a line drawn between two points.</summary>
        /// <param name="LineSegmentXamlElement">Non strongly typed Xaml Element</param>
        this.element = LineSegmentXamlElement;
}
LineSegment.createFromXaml = function(Host)
{
    /// <returns type="LineSegment" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new LineSegment(Host.content.createFromXaml("<LineSegment />"));
    } catch (ex) {}
    if (Host.getHost)
        return LineSegment.CreateNew(Host.getHost());
    return;
}
LineSegment.get_PointProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("LineSegment.Point");
}

LineSegment.prototype = new PathSegment;

LineSegment.prototype.set_point = function(value)
{
    /// <summary>Gets or sets the endpoint of the elliptical arc.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.point = value.element;
}

LineSegment.prototype.get_point = function()
{
    /// <summary>Gets or sets the endpoint of the elliptical arc.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.point);
}

BezierSegment = function(BezierSegmentXamlElement) 
{
        /// <summary>Represents a cubic Bezier curve drawn between two points.</summary>
        /// <param name="BezierSegmentXamlElement">Non strongly typed Xaml Element</param>
        this.element = BezierSegmentXamlElement;
}
BezierSegment.createFromXaml = function(Host)
{
    /// <returns type="BezierSegment" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new BezierSegment(Host.content.createFromXaml("<BezierSegment />"));
    } catch (ex) {}
    if (Host.getHost)
        return BezierSegment.CreateNew(Host.getHost());
    return;
}
BezierSegment.get_Point1Property = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("BezierSegment.Point1");
}

BezierSegment.get_Point2Property = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("BezierSegment.Point2");
}

BezierSegment.get_Point3Property = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("BezierSegment.Point3");
}

BezierSegment.prototype = new PathSegment;

BezierSegment.prototype.set_point1 = function(value)
{
    /// <summary>Gets or sets the first control point of the curve.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.point1 = value.element;
}

BezierSegment.prototype.get_point1 = function()
{
    /// <summary>Gets or sets the first control point of the curve.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.point1);
}

BezierSegment.prototype.set_point2 = function(value)
{
    /// <summary>Gets or sets the second control point of the curve.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.point2 = value.element;
}

BezierSegment.prototype.get_point2 = function()
{
    /// <summary>Gets or sets the second control point of the curve.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.point2);
}

BezierSegment.prototype.set_point3 = function(value)
{
    /// <summary>Gets or sets the end point of the curve.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.point3 = value.element;
}

BezierSegment.prototype.get_point3 = function()
{
    /// <summary>Gets or sets the end point of the curve.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.point3);
}

QuadraticBezierSegment = function(QuadraticBezierSegmentXamlElement) 
{
        /// <summary>Creates a quadratic Bezier curve between two points in a PathFigure.</summary>
        /// <param name="QuadraticBezierSegmentXamlElement">Non strongly typed Xaml Element</param>
        this.element = QuadraticBezierSegmentXamlElement;
}
QuadraticBezierSegment.createFromXaml = function(Host)
{
    /// <returns type="QuadraticBezierSegment" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new QuadraticBezierSegment(Host.content.createFromXaml("<QuadraticBezierSegment />"));
    } catch (ex) {}
    if (Host.getHost)
        return QuadraticBezierSegment.CreateNew(Host.getHost());
    return;
}
QuadraticBezierSegment.get_Point1Property = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("QuadraticBezierSegment.Point1");
}

QuadraticBezierSegment.get_Point2Property = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("QuadraticBezierSegment.Point2");
}

QuadraticBezierSegment.prototype = new PathSegment;

QuadraticBezierSegment.prototype.set_point1 = function(value)
{
    /// <summary>Gets or sets the first control point of the curve.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.point1 = value.element;
}

QuadraticBezierSegment.prototype.get_point1 = function()
{
    /// <summary>Gets or sets the first control point of the curve.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.point1);
}

QuadraticBezierSegment.prototype.set_point2 = function(value)
{
    /// <summary>Gets or sets the second control point of the curve.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.point2 = value.element;
}

QuadraticBezierSegment.prototype.get_point2 = function()
{
    /// <summary>Gets or sets the second control point of the curve.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.point2);
}

ArcSegment = function(ArcSegmentXamlElement) 
{
        /// <summary>Represents an elliptical arc between two points.</summary>
        /// <param name="ArcSegmentXamlElement">Non strongly typed Xaml Element</param>
        this.element = ArcSegmentXamlElement;
}
ArcSegment.createFromXaml = function(Host)
{
    /// <returns type="ArcSegment" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new ArcSegment(Host.content.createFromXaml("<ArcSegment />"));
    } catch (ex) {}
    if (Host.getHost)
        return ArcSegment.CreateNew(Host.getHost());
    return;
}
ArcSegment.get_PointProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ArcSegment.Point");
}

ArcSegment.get_SizeProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ArcSegment.Size");
}

ArcSegment.get_RotationAngleProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ArcSegment.RotationAngle");
}

ArcSegment.get_IsLargeArcProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ArcSegment.IsLargeArc");
}

ArcSegment.get_SweepDirectionProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ArcSegment.SweepDirection");
}

ArcSegment.prototype = new PathSegment;

ArcSegment.prototype.set_point = function(value)
{
    /// <summary>Gets or sets the endpoint of the elliptical arc.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.point = value.element;
}

ArcSegment.prototype.get_point = function()
{
    /// <summary>Gets or sets the endpoint of the elliptical arc.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.point);
}

ArcSegment.prototype.set_size = function(value)
{
    /// <summary>Gets or sets the x- and y-radius of the arc as a Size structure.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.size = value.element;
}

ArcSegment.prototype.get_size = function()
{
    /// <summary>Gets or sets the x- and y-radius of the arc as a Size structure.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.size);
}

ArcSegment.prototype.set_rotationAngle = function(value)
{
    /// <summary>Gets or sets the amount (in degrees) by which the ellipse is rotated about the x-axis.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.rotationAngle = value;
}

ArcSegment.prototype.get_rotationAngle = function()
{
    /// <summary>Gets or sets the amount (in degrees) by which the ellipse is rotated about the x-axis.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.rotationAngle);
}

ArcSegment.prototype.set_isLargeArc = function(value)
{
    /// <summary>Gets or sets a value that indicates whether the arc should be greater than 180 degrees.</summary>
    /// <param name="value" type="Boolean" integer="False" />
    TypeSafety({"Boolean" : value});   
    this.element.isLargeArc = value;
}

ArcSegment.prototype.get_isLargeArc = function()
{
    /// <summary>Gets or sets a value that indicates whether the arc should be greater than 180 degrees.</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.isLargeArc);
}

ArcSegment.prototype.set_sweepDirection = function(value)
{
    /// <summary>Gets or sets a value that specifies whether the arc is drawn in the Clockwise or Counterclockwise direction.</summary>
    /// <param name="value" type="SweepDirection" integer="False" />
    TypeSafety({"SweepDirection" : value});   
    this.element.sweepDirection = value.element;
}

ArcSegment.prototype.get_sweepDirection = function()
{
    /// <summary>Gets or sets a value that specifies whether the arc is drawn in the Clockwise or Counterclockwise direction.</summary>
    /// <returns type="SweepDirection" integer="False" />   
    return Convert.ToSweepDirection(this.element.sweepDirection);
}

PolyLineSegment = function(PolyLineSegmentXamlElement) 
{
        /// <summary>Represents a set of line segments defined by a PointCollection with each Point specifying the end point of a line segment.</summary>
        /// <param name="PolyLineSegmentXamlElement">Non strongly typed Xaml Element</param>
        this.element = PolyLineSegmentXamlElement;
}
PolyLineSegment.createFromXaml = function(Host)
{
    /// <returns type="PolyLineSegment" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new PolyLineSegment(Host.content.createFromXaml("<PolyLineSegment />"));
    } catch (ex) {}
    if (Host.getHost)
        return PolyLineSegment.CreateNew(Host.getHost());
    return;
}
PolyLineSegment.get_PointsProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("PolyLineSegment.Points");
}

PolyLineSegment.prototype = new PathSegment;

PolyLineSegment.prototype.set_points = function(value)
{
    /// <summary>Gets or sets the PointCollection that define this PolyBezierSegment object.</summary>
    /// <param name="value" type="Point[]" integer="False" />
    TypeSafety({"Point[]" : value});   
    this.element.points = value;
}

PolyBezierSegment = function(PolyBezierSegmentXamlElement) 
{
        /// <summary>Represents one or more cubic Bezier curves.</summary>
        /// <param name="PolyBezierSegmentXamlElement">Non strongly typed Xaml Element</param>
        this.element = PolyBezierSegmentXamlElement;
}
PolyBezierSegment.createFromXaml = function(Host)
{
    /// <returns type="PolyBezierSegment" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new PolyBezierSegment(Host.content.createFromXaml("<PolyBezierSegment />"));
    } catch (ex) {}
    if (Host.getHost)
        return PolyBezierSegment.CreateNew(Host.getHost());
    return;
}
PolyBezierSegment.get_PointsProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("PolyBezierSegment.Points");
}

PolyBezierSegment.prototype = new PathSegment;

PolyBezierSegment.prototype.set_points = function(value)
{
    /// <summary>Gets or sets the PointCollection that define this PolyBezierSegment object.</summary>
    /// <param name="value" type="Point[]" integer="False" />
    TypeSafety({"Point[]" : value});   
    this.element.points = value;
}

PolyQuadraticBezierSegment = function(PolyQuadraticBezierSegmentXamlElement) 
{
        /// <summary>Represents a set of quadratic Bezier segments.</summary>
        /// <param name="PolyQuadraticBezierSegmentXamlElement">Non strongly typed Xaml Element</param>
        this.element = PolyQuadraticBezierSegmentXamlElement;
}
PolyQuadraticBezierSegment.createFromXaml = function(Host)
{
    /// <returns type="PolyQuadraticBezierSegment" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new PolyQuadraticBezierSegment(Host.content.createFromXaml("<PolyQuadraticBezierSegment />"));
    } catch (ex) {}
    if (Host.getHost)
        return PolyQuadraticBezierSegment.CreateNew(Host.getHost());
    return;
}
PolyQuadraticBezierSegment.get_PointsProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("PolyQuadraticBezierSegment.Points");
}

PolyQuadraticBezierSegment.prototype = new PathSegment;

PolyQuadraticBezierSegment.prototype.set_points = function(value)
{
    /// <summary>Gets or sets the PointCollection that define this PolyBezierSegment object.</summary>
    /// <param name="value" type="Point[]" integer="False" />
    TypeSafety({"Point[]" : value});   
    this.element.points = value;
}

PathSegmentCollection = function(PathSegmentCollectionXamlElement) 
{
        /// <summary>Represents a collection of PathSegment objects that can be individually accessed by index.</summary>
        /// <param name="PathSegmentCollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = PathSegmentCollectionXamlElement;
}
PathSegmentCollection.createFromXaml = function(Host)
{
    /// <returns type="PathSegmentCollection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new PathSegmentCollection(Host.content.createFromXaml("<PathSegmentCollection />"));
    } catch (ex) {}
    if (Host.getHost)
        return PathSegmentCollection.CreateNew(Host.getHost());
    return;
}
PathSegmentCollection.prototype = new Collection;

PathSegmentCollection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="PathSegment" integer="False" />   
    return Convert.ToPathSegment(this.element.getItem(Index));
}

PathSegmentCollection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="PathSegment" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"PathSegment":value});
    return (this.element.add(value.element));
}

PathSegmentCollection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="PathSegment" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"PathSegment":value});
    return (this.element.contains(value.element));
}

PathSegmentCollection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="PathSegment" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"PathSegment":value});
    return (this.element.indexOf(value.element));
}

PathSegmentCollection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="PathSegment" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "PathSegment":value});
    return (this.element.insert(index, value.element));
}

PathSegmentCollection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="PathSegment" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"PathSegment":value});
    return (this.element.remove(value.element));
}

PathSegmentCollection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="PathSegment[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"PathSegment[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

PathFigure = function(PathFigureXamlElement) 
{
        /// <summary>Represents a subsection of a geometry, a single connected series of two-dimensional geometric segments.</summary>
        /// <param name="PathFigureXamlElement">Non strongly typed Xaml Element</param>
        this.element = PathFigureXamlElement;
}
PathFigure.createFromXaml = function(Host)
{
    /// <returns type="PathFigure" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new PathFigure(Host.content.createFromXaml("<PathFigure />"));
    } catch (ex) {}
    if (Host.getHost)
        return PathFigure.CreateNew(Host.getHost());
    return;
}
PathFigure.get_SegmentsProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("PathFigure.Segments");
}

PathFigure.get_StartPointProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("PathFigure.StartPoint");
}

PathFigure.get_IsClosedProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("PathFigure.IsClosed");
}

PathFigure.prototype = new DependencyObject;

PathFigure.prototype.set_segments = function(value)
{
    /// <summary>Gets or sets the collection of segments that define the shape of this PathFigure object.</summary>
    /// <param name="value" type="PathSegmentCollection" integer="False" />
    TypeSafety({"PathSegmentCollection" : value});   
    this.element.segments = value.element;
}

PathFigure.prototype.get_segments = function()
{
    /// <summary>Gets or sets the collection of segments that define the shape of this PathFigure object.</summary>
    /// <returns type="PathSegmentCollection" integer="False" />   
    return Convert.ToPathSegmentCollection(this.element.segments);
}

PathFigure.prototype.set_startPoint = function(value)
{
    /// <summary>Gets or sets the starting two-dimensional coordinates of the linear gradient.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.startPoint = value.element;
}

PathFigure.prototype.get_startPoint = function()
{
    /// <summary>Gets or sets the starting two-dimensional coordinates of the linear gradient.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.startPoint);
}

PathFigure.prototype.set_isClosed = function(value)
{
    /// <summary>Gets or sets a value that specifies whether this figures first and last segments are connected.</summary>
    /// <param name="value" type="Boolean" integer="False" />
    TypeSafety({"Boolean" : value});   
    this.element.isClosed = value;
}

PathFigure.prototype.get_isClosed = function()
{
    /// <summary>Gets or sets a value that specifies whether this figures first and last segments are connected.</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.isClosed);
}

PathFigureCollection = function(PathFigureCollectionXamlElement) 
{
        /// <summary>Represents a collection of PathFigure objects that collectively make up the geometry of a PathGeometry.</summary>
        /// <param name="PathFigureCollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = PathFigureCollectionXamlElement;
}
PathFigureCollection.createFromXaml = function(Host)
{
    /// <returns type="PathFigureCollection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new PathFigureCollection(Host.content.createFromXaml("<PathFigureCollection />"));
    } catch (ex) {}
    if (Host.getHost)
        return PathFigureCollection.CreateNew(Host.getHost());
    return;
}
PathFigureCollection.prototype = new Collection;

PathFigureCollection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="PathFigure" integer="False" />   
    return Convert.ToPathFigure(this.element.getItem(Index));
}

PathFigureCollection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="PathFigure" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"PathFigure":value});
    return (this.element.add(value.element));
}

PathFigureCollection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="PathFigure" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"PathFigure":value});
    return (this.element.contains(value.element));
}

PathFigureCollection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="PathFigure" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"PathFigure":value});
    return (this.element.indexOf(value.element));
}

PathFigureCollection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="PathFigure" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "PathFigure":value});
    return (this.element.insert(index, value.element));
}

PathFigureCollection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="PathFigure" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"PathFigure":value});
    return (this.element.remove(value.element));
}

PathFigureCollection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="PathFigure[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"PathFigure[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

PathGeometry = function(PathGeometryXamlElement) 
{
        /// <summary>Represents a complex shape that may be composed of arcs, curves, ellipses, lines, and rectangles.</summary>
        /// <param name="PathGeometryXamlElement">Non strongly typed Xaml Element</param>
        this.element = PathGeometryXamlElement;
}
PathGeometry.createFromXaml = function(Host)
{
    /// <returns type="PathGeometry" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new PathGeometry(Host.content.createFromXaml("<PathGeometry />"));
    } catch (ex) {}
    if (Host.getHost)
        return PathGeometry.CreateNew(Host.getHost());
    return;
}
PathGeometry.get_FiguresProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("PathGeometry.Figures");
}

PathGeometry.prototype = new Geometry;

PathGeometry.prototype.set_figures = function(value)
{
    /// <summary>Gets or sets the collection of PathFigure objects that describe the path's contents.</summary>
    /// <param name="value" type="PathFigureCollection" integer="False" />
    TypeSafety({"PathFigureCollection" : value});   
    this.element.figures = value.element;
}

PathGeometry.prototype.get_figures = function()
{
    /// <summary>Gets or sets the collection of PathFigure objects that describe the path's contents.</summary>
    /// <returns type="PathFigureCollection" integer="False" />   
    return Convert.ToPathFigureCollection(this.element.figures);
}

EllipseGeometry = function(EllipseGeometryXamlElement) 
{
        /// <summary>Represents the geometry of a circle or ellipse.</summary>
        /// <param name="EllipseGeometryXamlElement">Non strongly typed Xaml Element</param>
        this.element = EllipseGeometryXamlElement;
}
EllipseGeometry.createFromXaml = function(Host)
{
    /// <returns type="EllipseGeometry" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new EllipseGeometry(Host.content.createFromXaml("<EllipseGeometry />"));
    } catch (ex) {}
    if (Host.getHost)
        return EllipseGeometry.CreateNew(Host.getHost());
    return;
}
EllipseGeometry.get_CenterProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("EllipseGeometry.Center");
}

EllipseGeometry.get_RadiusXProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("EllipseGeometry.RadiusX");
}

EllipseGeometry.get_RadiusYProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("EllipseGeometry.RadiusY");
}

EllipseGeometry.prototype = new Geometry;

EllipseGeometry.prototype.set_center = function(value)
{
    /// <summary>Gets or sets the center point of the EllipseGeometry.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.center = value.element;
}

EllipseGeometry.prototype.get_center = function()
{
    /// <summary>Gets or sets the center point of the EllipseGeometry.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.center);
}

EllipseGeometry.prototype.set_radiusX = function(value)
{
    /// <summary>Gets or sets the x-radius value of the EllipseGeometry.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.radiusX = value;
}

EllipseGeometry.prototype.get_radiusX = function()
{
    /// <summary>Gets or sets the x-radius value of the EllipseGeometry.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.radiusX);
}

EllipseGeometry.prototype.set_radiusY = function(value)
{
    /// <summary>Gets or sets the y-radius value of the EllipseGeometry.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.radiusY = value;
}

EllipseGeometry.prototype.get_radiusY = function()
{
    /// <summary>Gets or sets the y-radius value of the EllipseGeometry.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.radiusY);
}

RectangleGeometry = function(RectangleGeometryXamlElement) 
{
        /// <summary>Describes a two-dimensional rectangle.</summary>
        /// <param name="RectangleGeometryXamlElement">Non strongly typed Xaml Element</param>
        this.element = RectangleGeometryXamlElement;
}
RectangleGeometry.createFromXaml = function(Host)
{
    /// <returns type="RectangleGeometry" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new RectangleGeometry(Host.content.createFromXaml("<RectangleGeometry />"));
    } catch (ex) {}
    if (Host.getHost)
        return RectangleGeometry.CreateNew(Host.getHost());
    return;
}
RectangleGeometry.get_RectProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("RectangleGeometry.Rect");
}

RectangleGeometry.get_RadiusXProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("RectangleGeometry.RadiusX");
}

RectangleGeometry.get_RadiusYProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("RectangleGeometry.RadiusY");
}

RectangleGeometry.prototype = new Geometry;

RectangleGeometry.prototype.set_rect = function(value)
{
    /// <summary>Gets or sets the dimensions of the rectangle.</summary>
    /// <param name="value" type="Rect" integer="False" />
    TypeSafety({"Rect" : value});   
    this.element.rect = value.element;
}

RectangleGeometry.prototype.get_rect = function()
{
    /// <summary>Gets or sets the dimensions of the rectangle.</summary>
    /// <returns type="Rect" integer="False" />   
    return Convert.ToRect(this.element.rect);
}

RectangleGeometry.prototype.set_radiusX = function(value)
{
    /// <summary>Gets or sets the x-radius value of the EllipseGeometry.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.radiusX = value;
}

RectangleGeometry.prototype.get_radiusX = function()
{
    /// <summary>Gets or sets the x-radius value of the EllipseGeometry.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.radiusX);
}

RectangleGeometry.prototype.set_radiusY = function(value)
{
    /// <summary>Gets or sets the y-radius value of the EllipseGeometry.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.radiusY = value;
}

RectangleGeometry.prototype.get_radiusY = function()
{
    /// <summary>Gets or sets the y-radius value of the EllipseGeometry.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.radiusY);
}

LineGeometry = function(LineGeometryXamlElement) 
{
        /// <summary>Represents the geometry of a line.</summary>
        /// <param name="LineGeometryXamlElement">Non strongly typed Xaml Element</param>
        this.element = LineGeometryXamlElement;
}
LineGeometry.createFromXaml = function(Host)
{
    /// <returns type="LineGeometry" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new LineGeometry(Host.content.createFromXaml("<LineGeometry />"));
    } catch (ex) {}
    if (Host.getHost)
        return LineGeometry.CreateNew(Host.getHost());
    return;
}
LineGeometry.get_StartPointProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("LineGeometry.StartPoint");
}

LineGeometry.get_EndPointProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("LineGeometry.EndPoint");
}

LineGeometry.prototype = new Geometry;

LineGeometry.prototype.set_startPoint = function(value)
{
    /// <summary>Gets or sets the starting two-dimensional coordinates of the linear gradient.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.startPoint = value.element;
}

LineGeometry.prototype.get_startPoint = function()
{
    /// <summary>Gets or sets the starting two-dimensional coordinates of the linear gradient.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.startPoint);
}

LineGeometry.prototype.set_endPoint = function(value)
{
    /// <summary>Gets or sets the ending two-dimensional coordinates of the linear gradient.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.endPoint = value.element;
}

LineGeometry.prototype.get_endPoint = function()
{
    /// <summary>Gets or sets the ending two-dimensional coordinates of the linear gradient.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.endPoint);
}

GeometryCollection = function(GeometryCollectionXamlElement) 
{
        /// <summary>Represents a collection of Geometry objects.</summary>
        /// <param name="GeometryCollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = GeometryCollectionXamlElement;
}
GeometryCollection.createFromXaml = function(Host)
{
    /// <returns type="GeometryCollection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new GeometryCollection(Host.content.createFromXaml("<GeometryCollection />"));
    } catch (ex) {}
    if (Host.getHost)
        return GeometryCollection.CreateNew(Host.getHost());
    return;
}
GeometryCollection.prototype = new Collection;

GeometryCollection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="Geometry" integer="False" />   
    return Convert.ToGeometry(this.element.getItem(Index));
}

GeometryCollection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="Geometry" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"Geometry":value});
    return (this.element.add(value.element));
}

GeometryCollection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="Geometry" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Geometry":value});
    return (this.element.contains(value.element));
}

GeometryCollection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="Geometry" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Geometry":value});
    return (this.element.indexOf(value.element));
}

GeometryCollection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="Geometry" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "Geometry":value});
    return (this.element.insert(index, value.element));
}

GeometryCollection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="Geometry" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Geometry":value});
    return (this.element.remove(value.element));
}

GeometryCollection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="Geometry[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"Geometry[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

GeometryGroup = function(GeometryGroupXamlElement) 
{
        /// <summary>Represents a composite geometry, composed of other Geometry objects.</summary>
        /// <param name="GeometryGroupXamlElement">Non strongly typed Xaml Element</param>
        this.element = GeometryGroupXamlElement;
}
GeometryGroup.createFromXaml = function(Host)
{
    /// <returns type="GeometryGroup" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new GeometryGroup(Host.content.createFromXaml("<GeometryGroup />"));
    } catch (ex) {}
    if (Host.getHost)
        return GeometryGroup.CreateNew(Host.getHost());
    return;
}
GeometryGroup.get_ChildrenProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("GeometryGroup.Children");
}

GeometryGroup.prototype = new Geometry;

GeometryGroup.prototype.set_children = function(value)
{
    /// <summary>Gets or sets the collection of child elements on the Canvas.</summary>
    /// <param name="value" type="GeometryCollection" integer="False" />
    TypeSafety({"GeometryCollection" : value});   
    this.element.children = value.element;
}

GeometryGroup.prototype.get_children = function()
{
    /// <summary>Gets or sets the collection of child elements on the Canvas.</summary>
    /// <returns type="GeometryCollection" integer="False" />   
    return Convert.ToGeometryCollection(this.element.children);
}

SolidColorBrush = function(SolidColorBrushXamlElement) 
{
        /// <summary>Paints an area with a solid color.</summary>
        /// <param name="SolidColorBrushXamlElement">Non strongly typed Xaml Element</param>
        this.element = SolidColorBrushXamlElement;
}
SolidColorBrush.createFromXaml = function(Host)
{
    /// <returns type="SolidColorBrush" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new SolidColorBrush(Host.content.createFromXaml("<SolidColorBrush />"));
    } catch (ex) {}
    if (Host.getHost)
        return SolidColorBrush.CreateNew(Host.getHost());
    return;
}
SolidColorBrush.get_ColorProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("SolidColorBrush.Color");
}

SolidColorBrush.prototype = new Brush;

SolidColorBrush.prototype.set_color = function(value)
{
    /// <summary>The color of the associated stroke.</summary>
    /// <param name="value" type="Color" integer="False" />
    TypeSafety({"Color" : value});   
    this.element.color = value.element;
}

SolidColorBrush.prototype.get_color = function()
{
    /// <summary>The color of the associated stroke.</summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.color);
}

GradientStop = function(GradientStopXamlElement) 
{
        /// <summary>Describes the location and color of a transition point in a gradient.</summary>
        /// <param name="GradientStopXamlElement">Non strongly typed Xaml Element</param>
        this.element = GradientStopXamlElement;
}
GradientStop.createFromXaml = function(Host)
{
    /// <returns type="GradientStop" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new GradientStop(Host.content.createFromXaml("<GradientStop />"));
    } catch (ex) {}
    if (Host.getHost)
        return GradientStop.CreateNew(Host.getHost());
    return;
}
GradientStop.get_ColorProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("GradientStop.Color");
}

GradientStop.get_OffsetProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("GradientStop.Offset");
}

GradientStop.prototype = new DependencyObject;

GradientStop.prototype.set_color = function(value)
{
    /// <summary>The color of the associated stroke.</summary>
    /// <param name="value" type="Color" integer="False" />
    TypeSafety({"Color" : value});   
    this.element.color = value.element;
}

GradientStop.prototype.get_color = function()
{
    /// <summary>The color of the associated stroke.</summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.color);
}

GradientStop.prototype.set_offset = function(value)
{
    /// <summary>Gets the location of the gradient stop within the gradient vector.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.offset = value;
}

GradientStop.prototype.get_offset = function()
{
    /// <summary>Gets the location of the gradient stop within the gradient vector.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.offset);
}

GradientStopCollection = function(GradientStopCollectionXamlElement) 
{
        /// <summary>Represents a collection of GradientStop objects that can be individually accessed by index.</summary>
        /// <param name="GradientStopCollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = GradientStopCollectionXamlElement;
}
GradientStopCollection.createFromXaml = function(Host)
{
    /// <returns type="GradientStopCollection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new GradientStopCollection(Host.content.createFromXaml("<GradientStopCollection />"));
    } catch (ex) {}
    if (Host.getHost)
        return GradientStopCollection.CreateNew(Host.getHost());
    return;
}
GradientStopCollection.prototype = new Collection;

GradientStopCollection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="GradientStop" integer="False" />   
    return Convert.ToGradientStop(this.element.getItem(Index));
}

GradientStopCollection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="GradientStop" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"GradientStop":value});
    return (this.element.add(value.element));
}

GradientStopCollection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="GradientStop" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"GradientStop":value});
    return (this.element.contains(value.element));
}

GradientStopCollection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="GradientStop" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"GradientStop":value});
    return (this.element.indexOf(value.element));
}

GradientStopCollection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="GradientStop" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "GradientStop":value});
    return (this.element.insert(index, value.element));
}

GradientStopCollection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="GradientStop" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"GradientStop":value});
    return (this.element.remove(value.element));
}

GradientStopCollection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="GradientStop[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"GradientStop[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

GradientBrush = function(GradientBrushXamlElement) 
{
        /// <summary>Describes a gradient which is composed of gradient stops.</summary>
        /// <param name="GradientBrushXamlElement">Non strongly typed Xaml Element</param>
        this.element = GradientBrushXamlElement;
}
GradientBrush.createFromXaml = function(Host)
{
    /// <returns type="GradientBrush" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new GradientBrush(Host.content.createFromXaml("<GradientBrush />"));
    } catch (ex) {}
    if (Host.getHost)
        return GradientBrush.CreateNew(Host.getHost());
    return;
}
GradientBrush.get_SpreadMethodProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("GradientBrush.SpreadMethod");
}

GradientBrush.get_MappingModeProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("GradientBrush.MappingMode");
}

GradientBrush.get_ColorInterpolationModeProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("GradientBrush.ColorInterpolationMode");
}

GradientBrush.get_GradientStopsProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("GradientBrush.GradientStops");
}

GradientBrush.prototype = new Brush;

GradientBrush.prototype.set_spreadMethod = function(value)
{
    /// <summary>Gets or sets the type of spread method that specifies how to draw a gradient that starts or ends inside the bounds of the object to be painted.</summary>
    /// <param name="value" type="GradientSpreadMethod" integer="False" />
    TypeSafety({"GradientSpreadMethod" : value});   
    this.element.spreadMethod = value.element;
}

GradientBrush.prototype.get_spreadMethod = function()
{
    /// <summary>Gets or sets the type of spread method that specifies how to draw a gradient that starts or ends inside the bounds of the object to be painted.</summary>
    /// <returns type="GradientSpreadMethod" integer="False" />   
    return Convert.ToGradientSpreadMethod(this.element.spreadMethod);
}

GradientBrush.prototype.set_mappingMode = function(value)
{
    /// <summary>Gets or sets a BrushMappingMode enumeration that specifies whether the gradient brush's positioning coordinates are absolute or relative to the output area.</summary>
    /// <param name="value" type="BrushMappingMode" integer="False" />
    TypeSafety({"BrushMappingMode" : value});   
    this.element.mappingMode = value.element;
}

GradientBrush.prototype.get_mappingMode = function()
{
    /// <summary>Gets or sets a BrushMappingMode enumeration that specifies whether the gradient brush's positioning coordinates are absolute or relative to the output area.</summary>
    /// <returns type="BrushMappingMode" integer="False" />   
    return Convert.ToBrushMappingMode(this.element.mappingMode);
}

GradientBrush.prototype.set_colorInterpolationMode = function(value)
{
    /// <summary>Gets or sets a ColorInterpolationMode enumeration that specifies how the gradient's colors are interpolated.</summary>
    /// <param name="value" type="ColorInterpolationMode" integer="False" />
    TypeSafety({"ColorInterpolationMode" : value});   
    this.element.colorInterpolationMode = value.element;
}

GradientBrush.prototype.get_colorInterpolationMode = function()
{
    /// <summary>Gets or sets a ColorInterpolationMode enumeration that specifies how the gradient's colors are interpolated.</summary>
    /// <returns type="ColorInterpolationMode" integer="False" />   
    return Convert.ToColorInterpolationMode(this.element.colorInterpolationMode);
}

GradientBrush.prototype.set_gradientStops = function(value)
{
    /// <summary>Gets or sets the brush's gradient stops.</summary>
    /// <param name="value" type="GradientStopCollection" integer="False" />
    TypeSafety({"GradientStopCollection" : value});   
    this.element.gradientStops = value.element;
}

GradientBrush.prototype.get_gradientStops = function()
{
    /// <summary>Gets or sets the brush's gradient stops.</summary>
    /// <returns type="GradientStopCollection" integer="False" />   
    return Convert.ToGradientStopCollection(this.element.gradientStops);
}

LinearGradientBrush = function(LinearGradientBrushXamlElement) 
{
        /// <summary>Paints an area with a linear gradient.</summary>
        /// <param name="LinearGradientBrushXamlElement">Non strongly typed Xaml Element</param>
        this.element = LinearGradientBrushXamlElement;
}
LinearGradientBrush.createFromXaml = function(Host)
{
    /// <returns type="LinearGradientBrush" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new LinearGradientBrush(Host.content.createFromXaml("<LinearGradientBrush />"));
    } catch (ex) {}
    if (Host.getHost)
        return LinearGradientBrush.CreateNew(Host.getHost());
    return;
}
LinearGradientBrush.get_StartPointProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("LinearGradientBrush.StartPoint");
}

LinearGradientBrush.get_EndPointProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("LinearGradientBrush.EndPoint");
}

LinearGradientBrush.prototype = new GradientBrush;

LinearGradientBrush.prototype.set_startPoint = function(value)
{
    /// <summary>Gets or sets the starting two-dimensional coordinates of the linear gradient.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.startPoint = value.element;
}

LinearGradientBrush.prototype.get_startPoint = function()
{
    /// <summary>Gets or sets the starting two-dimensional coordinates of the linear gradient.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.startPoint);
}

LinearGradientBrush.prototype.set_endPoint = function(value)
{
    /// <summary>Gets or sets the ending two-dimensional coordinates of the linear gradient.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.endPoint = value.element;
}

LinearGradientBrush.prototype.get_endPoint = function()
{
    /// <summary>Gets or sets the ending two-dimensional coordinates of the linear gradient.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.endPoint);
}

RadialGradientBrush = function(RadialGradientBrushXamlElement) 
{
        /// <summary>Paints an area with a radial gradient. A focal point defines the beginning of the gradient, and a circle defines the end point of the gradient.</summary>
        /// <param name="RadialGradientBrushXamlElement">Non strongly typed Xaml Element</param>
        this.element = RadialGradientBrushXamlElement;
}
RadialGradientBrush.createFromXaml = function(Host)
{
    /// <returns type="RadialGradientBrush" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new RadialGradientBrush(Host.content.createFromXaml("<RadialGradientBrush />"));
    } catch (ex) {}
    if (Host.getHost)
        return RadialGradientBrush.CreateNew(Host.getHost());
    return;
}
RadialGradientBrush.get_CenterProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("RadialGradientBrush.Center");
}

RadialGradientBrush.get_GradientOriginProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("RadialGradientBrush.GradientOrigin");
}

RadialGradientBrush.get_RadiusXProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("RadialGradientBrush.RadiusX");
}

RadialGradientBrush.get_RadiusYProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("RadialGradientBrush.RadiusY");
}

RadialGradientBrush.prototype = new GradientBrush;

RadialGradientBrush.prototype.set_center = function(value)
{
    /// <summary>Gets or sets the center point of the EllipseGeometry.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.center = value.element;
}

RadialGradientBrush.prototype.get_center = function()
{
    /// <summary>Gets or sets the center point of the EllipseGeometry.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.center);
}

RadialGradientBrush.prototype.set_gradientOrigin = function(value)
{
    /// <summary>Gets or sets the location of the two-dimensional focal point that defines the beginning of the gradient.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.gradientOrigin = value.element;
}

RadialGradientBrush.prototype.get_gradientOrigin = function()
{
    /// <summary>Gets or sets the location of the two-dimensional focal point that defines the beginning of the gradient.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.gradientOrigin);
}

RadialGradientBrush.prototype.set_radiusX = function(value)
{
    /// <summary>Gets or sets the x-radius value of the EllipseGeometry.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.radiusX = value;
}

RadialGradientBrush.prototype.get_radiusX = function()
{
    /// <summary>Gets or sets the x-radius value of the EllipseGeometry.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.radiusX);
}

RadialGradientBrush.prototype.set_radiusY = function(value)
{
    /// <summary>Gets or sets the y-radius value of the EllipseGeometry.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.radiusY = value;
}

RadialGradientBrush.prototype.get_radiusY = function()
{
    /// <summary>Gets or sets the y-radius value of the EllipseGeometry.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.radiusY);
}

ImageBrush = function(ImageBrushXamlElement) 
{
        /// <summary>Paints an area with an image.</summary>
        /// <param name="ImageBrushXamlElement">Non strongly typed Xaml Element</param>
        this.element = ImageBrushXamlElement;
}
ImageBrush.createFromXaml = function(Host)
{
    /// <returns type="ImageBrush" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new ImageBrush(Host.content.createFromXaml("<ImageBrush />"));
    } catch (ex) {}
    if (Host.getHost)
        return ImageBrush.CreateNew(Host.getHost());
    return;
}
ImageBrush.get_ImageSourceProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ImageBrush.ImageSource");
}

ImageBrush.get_DownloadProgressProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ImageBrush.DownloadProgress");
}

ImageBrush.prototype = new TileBrush;

ImageBrush.prototype.set_imageSource = function(value)
{
    /// <summary>Gets or sets the image displayed by this ImageBrush.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.imageSource = value;
}

ImageBrush.prototype.get_imageSource = function()
{
    /// <summary>Gets or sets the image displayed by this ImageBrush.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.imageSource);
}

ImageBrush.prototype.set_downloadProgress = function(value)
{
    /// <summary>Gets a value that indicates the percentage of downloaded content.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.downloadProgress = value;
}

ImageBrush.prototype.get_downloadProgress = function()
{
    /// <summary>Gets a value that indicates the percentage of downloaded content.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.downloadProgress);
}

ImageBrush.prototype.setSource = function(Downloader, PartName)
{
     /// <summary>Sets the source value of an object with downloaded content.</summary>
    /// <param name="Downloader" type="DependencyObject" integer="False" >The object containing the downloaded content.</param>   
    /// <param name="PartName" type="String" integer="False" >The name of the specific part of the downloaded content package. When the downloaded content package is a Zip file, part refers to the contents of a filename within downloader. If the downloaded content does not represent packaged content, set part to an empty string.</param>   
    TypeSafety({"DependencyObject":Downloader, "String":PartName});
    return (this.element.setSource(Downloader.element, PartName));
}

ImageBrush.prototype.add_ImageFailed = function(handler) {
    /// <summary>Occurs when there is a media related error.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("ImageFailed", handler);
}
    
ImageBrush.prototype.remove_ImageFailed = function(eventId) {
    /// <summary>Occurs when there is a media related error.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_ImageBrush</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("ImageFailed", eventId);
}

VideoBrush = function(VideoBrushXamlElement) 
{
        /// <summary>Paints an area with video.</summary>
        /// <param name="VideoBrushXamlElement">Non strongly typed Xaml Element</param>
        this.element = VideoBrushXamlElement;
}
VideoBrush.createFromXaml = function(Host)
{
    /// <returns type="VideoBrush" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new VideoBrush(Host.content.createFromXaml("<VideoBrush />"));
    } catch (ex) {}
    if (Host.getHost)
        return VideoBrush.CreateNew(Host.getHost());
    return;
}
VideoBrush.get_SourceNameProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("VideoBrush.SourceName");
}

VideoBrush.prototype = new TileBrush;

VideoBrush.prototype.set_sourceName = function(value)
{
    /// <summary>Gets or sets the Name of the MediaElement that provides video for this VideoBrush.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.sourceName = value;
}

VideoBrush.prototype.get_sourceName = function()
{
    /// <summary>Gets or sets the Name of the MediaElement that provides video for this VideoBrush.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.sourceName);
}

VisualCollection = function(VisualCollectionXamlElement) 
{
        /// <summary></summary>
        /// <param name="VisualCollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = VisualCollectionXamlElement;
}
VisualCollection.createFromXaml = function(Host)
{
    /// <returns type="VisualCollection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new VisualCollection(Host.content.createFromXaml("<VisualCollection />"));
    } catch (ex) {}
    if (Host.getHost)
        return VisualCollection.CreateNew(Host.getHost());
    return;
}
VisualCollection.prototype = new Collection;

VisualCollection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="Visual" integer="False" />   
    return Convert.ToVisual(this.element.getItem(Index));
}

VisualCollection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="Visual" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"Visual":value});
    return (this.element.add(value.element));
}

VisualCollection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="Visual" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Visual":value});
    return (this.element.contains(value.element));
}

VisualCollection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="Visual" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Visual":value});
    return (this.element.indexOf(value.element));
}

VisualCollection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="Visual" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "Visual":value});
    return (this.element.insert(index, value.element));
}

VisualCollection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="Visual" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Visual":value});
    return (this.element.remove(value.element));
}

VisualCollection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="Visual[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"Visual[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

TimelineCollection = function(TimelineCollectionXamlElement) 
{
        /// <summary>Represents a collection of Timeline objects.</summary>
        /// <param name="TimelineCollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = TimelineCollectionXamlElement;
}
TimelineCollection.createFromXaml = function(Host)
{
    /// <returns type="TimelineCollection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new TimelineCollection(Host.content.createFromXaml("<TimelineCollection />"));
    } catch (ex) {}
    if (Host.getHost)
        return TimelineCollection.CreateNew(Host.getHost());
    return;
}
TimelineCollection.prototype = new Collection;

TimelineCollection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="Timeline" integer="False" />   
    return Convert.ToTimeline(this.element.getItem(Index));
}

TimelineCollection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="Timeline" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"Timeline":value});
    return (this.element.add(value.element));
}

TimelineCollection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="Timeline" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Timeline":value});
    return (this.element.contains(value.element));
}

TimelineCollection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="Timeline" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Timeline":value});
    return (this.element.indexOf(value.element));
}

TimelineCollection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="Timeline" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "Timeline":value});
    return (this.element.insert(index, value.element));
}

TimelineCollection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="Timeline" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Timeline":value});
    return (this.element.remove(value.element));
}

TimelineCollection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="Timeline[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"Timeline[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

MediaAttribute = function(MediaAttributeXamlElement) 
{
        /// <summary>Represents an attribute from an entry in a ASX file.</summary>
        /// <param name="MediaAttributeXamlElement">Non strongly typed Xaml Element</param>
        this.element = MediaAttributeXamlElement;
}
MediaAttribute.createFromXaml = function(Host)
{
    /// <returns type="MediaAttribute" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new MediaAttribute(Host.content.createFromXaml("<MediaAttribute />"));
    } catch (ex) {}
    if (Host.getHost)
        return MediaAttribute.CreateNew(Host.getHost());
    return;
}
MediaAttribute.get_ValueProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaAttribute.Value");
}

MediaAttribute.prototype = new DependencyObject;

MediaAttribute.prototype.set_value = function(value)
{
    /// <summary>Gets or sets the key frame's target value.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.value = value;
}

MediaAttribute.prototype.get_value = function()
{
    /// <summary>Gets or sets the key frame's target value.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.value);
}

MediaAttributeCollection = function(MediaAttributeCollectionXamlElement) 
{
        /// <summary>Represents a collection of MediaAttribute objects.</summary>
        /// <param name="MediaAttributeCollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = MediaAttributeCollectionXamlElement;
}
MediaAttributeCollection.createFromXaml = function(Host)
{
    /// <returns type="MediaAttributeCollection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new MediaAttributeCollection(Host.content.createFromXaml("<MediaAttributeCollection />"));
    } catch (ex) {}
    if (Host.getHost)
        return MediaAttributeCollection.CreateNew(Host.getHost());
    return;
}
MediaAttributeCollection.prototype = new Collection;

MediaAttributeCollection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="MediaAttribute" integer="False" />   
    return Convert.ToMediaAttribute(this.element.getItem(Index));
}

MediaAttributeCollection.prototype.getItemByName = function(AttributeName)
{
     /// <summary>Gets the MediaAttribute for the collection with the Name equal to the specified string.</summary>
    /// <param name="AttributeName" type="String" integer="False" >The name of the MediaAttribute to get from the collection.</param>   
    /// <returns type="DependencyObject" integer="False" />   
    TypeSafety({"String":AttributeName});
    return Convert.ToDependencyObject(this.element.getItemByName(AttributeName));
}

MediaAttributeCollection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="MediaAttribute" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"MediaAttribute":value});
    return (this.element.add(value.element));
}

MediaAttributeCollection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="MediaAttribute" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"MediaAttribute":value});
    return (this.element.contains(value.element));
}

MediaAttributeCollection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="MediaAttribute" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"MediaAttribute":value});
    return (this.element.indexOf(value.element));
}

MediaAttributeCollection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="MediaAttribute" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "MediaAttribute":value});
    return (this.element.insert(index, value.element));
}

MediaAttributeCollection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="MediaAttribute" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"MediaAttribute":value});
    return (this.element.remove(value.element));
}

MediaAttributeCollection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="MediaAttribute[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"MediaAttribute[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

FillBehavior = function(FillBehaviorXamlElement) 
{
        /// <summary>Specifies how a Timeline behaves when it is outside its active period but its parent is inside its active or hold period.</summary>
        /// <param name="FillBehaviorXamlElement">Non strongly typed Xaml Element</param>
        this.element = FillBehaviorXamlElement;
}
FillBehavior.get_HoldEnd = function()
{
    /// <returns type="FillBehavior" />
    return Convert.ToFillBehavior("HoldEnd");
}

FillBehavior.is_HoldEnd = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FillBehavior" />
    return valueToCompare.element == "HoldEnd";
}

FillBehavior.get_Stop = function()
{
    /// <returns type="FillBehavior" />
    return Convert.ToFillBehavior("Stop");
}

FillBehavior.is_Stop = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="FillBehavior" />
    return valueToCompare.element == "Stop";
}

FillBehavior.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

FillBehavior.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

FillBehavior.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

FillBehavior.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

FillBehavior.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

FillBehavior.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

FillBehavior.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

FillBehavior.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

FillBehavior.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

FillBehavior.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

Timeline = function(TimelineXamlElement) 
{
        /// <summary>Defines a segment of time.</summary>
        /// <param name="TimelineXamlElement">Non strongly typed Xaml Element</param>
        this.element = TimelineXamlElement;
}
Timeline.createFromXaml = function(Host)
{
    /// <returns type="Timeline" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Timeline(Host.content.createFromXaml("<Timeline />"));
    } catch (ex) {}
    if (Host.getHost)
        return Timeline.CreateNew(Host.getHost());
    return;
}
Timeline.get_AutoReverseProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Timeline.AutoReverse");
}

Timeline.get_BeginTimeProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Timeline.BeginTime");
}

Timeline.get_DurationProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Timeline.Duration");
}

Timeline.get_SpeedRatioProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Timeline.SpeedRatio");
}

Timeline.get_FillBehaviorProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Timeline.FillBehavior");
}

Timeline.get_RepeatBehaviorProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Timeline.RepeatBehavior");
}

Timeline.prototype = new DependencyObject;

Timeline.prototype.set_autoReverse = function(value)
{
    /// <summary>Gets or sets a value that indicates whether the timeline plays in reverse after it completes a forward iteration.</summary>
    /// <param name="value" type="Boolean" integer="False" />
    TypeSafety({"Boolean" : value});   
    this.element.autoReverse = value;
}

Timeline.prototype.get_autoReverse = function()
{
    /// <summary>Gets or sets a value that indicates whether the timeline plays in reverse after it completes a forward iteration.</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.autoReverse);
}

Timeline.prototype.set_beginTime = function(value)
{
    /// <summary>Gets or sets the time at which this TimeLine should begin.</summary>
    /// <param name="value" type="TimeSpan" integer="False" />
    TypeSafety({"TimeSpan" : value});   
    this.element.beginTime = value;
}

Timeline.prototype.get_beginTime = function()
{
    /// <summary>Gets or sets the time at which this TimeLine should begin.</summary>
    /// <returns type="TimeSpan" integer="False" />   
    return (this.element.beginTime);
}

Timeline.prototype.set_duration = function(value)
{
    /// <summary>Gets the natural duration of the media.</summary>
    /// <param name="value" type="Duration" integer="False" />
    TypeSafety({"Duration" : value});   
    this.element.duration = value.element;
}

Timeline.prototype.get_duration = function()
{
    /// <summary>Gets the natural duration of the media.</summary>
    /// <returns type="Duration" integer="False" />   
    return Convert.ToDuration(this.element.duration);
}

Timeline.prototype.set_speedRatio = function(value)
{
    /// <summary>Gets or sets the rate, relative to its parent, at which time progresses for this TimeLine.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.speedRatio = value;
}

Timeline.prototype.get_speedRatio = function()
{
    /// <summary>Gets or sets the rate, relative to its parent, at which time progresses for this TimeLine.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.speedRatio);
}

Timeline.prototype.set_fillBehavior = function(value)
{
    /// <summary>Gets or sets a value that specifies how the TimeLine behaves after it reaches the end of its active period.</summary>
    /// <param name="value" type="FillBehavior" integer="False" />
    TypeSafety({"FillBehavior" : value});   
    this.element.fillBehavior = value.element;
}

Timeline.prototype.get_fillBehavior = function()
{
    /// <summary>Gets or sets a value that specifies how the TimeLine behaves after it reaches the end of its active period.</summary>
    /// <returns type="FillBehavior" integer="False" />   
    return Convert.ToFillBehavior(this.element.fillBehavior);
}

Timeline.prototype.set_repeatBehavior = function(value)
{
    /// <summary>Gets or sets the repeating behavior of this timeline.</summary>
    /// <param name="value" type="RepeatBehavior" integer="False" />
    TypeSafety({"RepeatBehavior" : value});   
    this.element.repeatBehavior = value.element;
}

Timeline.prototype.get_repeatBehavior = function()
{
    /// <summary>Gets or sets the repeating behavior of this timeline.</summary>
    /// <returns type="RepeatBehavior" integer="False" />   
    return Convert.ToRepeatBehavior(this.element.repeatBehavior);
}

TimelineGroup = function(TimelineGroupXamlElement) 
{
        /// <summary>Represents a Timeline that may contain a collection of child Timeline objects.</summary>
        /// <param name="TimelineGroupXamlElement">Non strongly typed Xaml Element</param>
        this.element = TimelineGroupXamlElement;
}
TimelineGroup.createFromXaml = function(Host)
{
    /// <returns type="TimelineGroup" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new TimelineGroup(Host.content.createFromXaml("<TimelineGroup />"));
    } catch (ex) {}
    if (Host.getHost)
        return TimelineGroup.CreateNew(Host.getHost());
    return;
}
TimelineGroup.get_ChildrenProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TimelineGroup.Children");
}

TimelineGroup.prototype = new Timeline;

TimelineGroup.prototype.set_children = function(value)
{
    /// <summary>Gets or sets the collection of child elements on the Canvas.</summary>
    /// <param name="value" type="TimelineCollection" integer="False" />
    TypeSafety({"TimelineCollection" : value});   
    this.element.children = value.element;
}

TimelineGroup.prototype.get_children = function()
{
    /// <summary>Gets or sets the collection of child elements on the Canvas.</summary>
    /// <returns type="TimelineCollection" integer="False" />   
    return Convert.ToTimelineCollection(this.element.children);
}

ParallelTimeline = function(ParallelTimelineXamlElement) 
{
        /// <summary></summary>
        /// <param name="ParallelTimelineXamlElement">Non strongly typed Xaml Element</param>
        this.element = ParallelTimelineXamlElement;
}
ParallelTimeline.createFromXaml = function(Host)
{
    /// <returns type="ParallelTimeline" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new ParallelTimeline(Host.content.createFromXaml("<ParallelTimeline />"));
    } catch (ex) {}
    if (Host.getHost)
        return ParallelTimeline.CreateNew(Host.getHost());
    return;
}
ParallelTimeline.prototype = new TimelineGroup;

BeginStoryboard = function(BeginStoryboardXamlElement) 
{
        /// <summary>A trigger action that begins a StoryBoard and distributes its animations to their targeted objects and properties.</summary>
        /// <param name="BeginStoryboardXamlElement">Non strongly typed Xaml Element</param>
        this.element = BeginStoryboardXamlElement;
}
BeginStoryboard.createFromXaml = function(Host)
{
    /// <returns type="BeginStoryboard" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new BeginStoryboard(Host.content.createFromXaml("<BeginStoryboard />"));
    } catch (ex) {}
    if (Host.getHost)
        return BeginStoryboard.CreateNew(Host.getHost());
    return;
}
BeginStoryboard.get_StoryboardProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("BeginStoryboard.Storyboard");
}

BeginStoryboard.prototype = new DependencyObject;

BeginStoryboard.prototype.set_storyboard = function(value)
{
    /// <summary>Gets or sets the StoryBoard that this BeginStoryBoard starts.</summary>
    /// <param name="value" type="Storyboard" integer="False" />
    TypeSafety({"Storyboard" : value});   
    this.element.storyboard = value.element;
}

BeginStoryboard.prototype.get_storyboard = function()
{
    /// <summary>Gets or sets the StoryBoard that this BeginStoryBoard starts.</summary>
    /// <returns type="Storyboard" integer="False" />   
    return Convert.ToStoryboard(this.element.storyboard);
}

Storyboard = function(StoryboardXamlElement) 
{
        /// <summary>Controls and provides object and property targeting information for its child animations.</summary>
        /// <param name="StoryboardXamlElement">Non strongly typed Xaml Element</param>
        this.element = StoryboardXamlElement;
}
Storyboard.createFromXaml = function(Host)
{
    /// <returns type="Storyboard" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Storyboard(Host.content.createFromXaml("<Storyboard />"));
    } catch (ex) {}
    if (Host.getHost)
        return Storyboard.CreateNew(Host.getHost());
    return;
}
Storyboard.get_TargetProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Storyboard.Target");
}

Storyboard.get_TargetNameProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Storyboard.TargetName");
}

Storyboard.prototype = new ParallelTimeline;

Storyboard.prototype.seek = function(timespan)
{
     /// <summary>Seeks this StoryBoard to a new position when the next clock tick occurs.</summary>
    /// <param name="timespan" type="String" integer="False" >A positive or negative value that describes the amount by which the timeline should move forward or backward from the beginning of the animation.</param>   
    TypeSafety({"String":timespan});
    return (this.element.seek(timespan));
}

Storyboard.prototype.stop = function()
{
     /// <summary>Stops and resets media to be played from the beginning.</summary>
    TypeSafety({});
    return (this.element.stop());
}

Storyboard.prototype.begin = function()
{
     /// <summary>Initiates the set of animations associated with this StoryBoard.</summary>
    TypeSafety({});
    return (this.element.begin());
}

Storyboard.prototype.pause = function()
{
     /// <summary>Pauses media at the current position.</summary>
    TypeSafety({});
    return (this.element.pause());
}

Storyboard.prototype.resume = function()
{
     /// <summary>Resumes the set of animations associated with this StoryBoard.</summary>
    TypeSafety({});
    return (this.element.resume());
}

Storyboard.prototype.add_Completed = function(handler) {
    /// <summary>Occurs when a download request completes with content.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("Completed", handler);
}
    
Storyboard.prototype.remove_Completed = function(eventId) {
    /// <summary>Occurs when a download request completes with content.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_Storyboard</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("Completed", eventId);
}

Animation = function(AnimationXamlElement) 
{
        /// <summary>Animates the value of a property between two target values using linear interpolation over a specified Duration.</summary>
        /// <param name="AnimationXamlElement">Non strongly typed Xaml Element</param>
        this.element = AnimationXamlElement;
}
Animation.createFromXaml = function(Host)
{
    /// <returns type="Animation" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Animation(Host.content.createFromXaml("<Animation />"));
    } catch (ex) {}
    if (Host.getHost)
        return Animation.CreateNew(Host.getHost());
    return;
}
Animation.prototype = new Timeline;

DoubleAnimation = function(DoubleAnimationXamlElement) 
{
        /// <summary>Animates the value of a Double property between two target values using linear interpolation over a specified Duration.</summary>
        /// <param name="DoubleAnimationXamlElement">Non strongly typed Xaml Element</param>
        this.element = DoubleAnimationXamlElement;
}
DoubleAnimation.createFromXaml = function(Host)
{
    /// <returns type="DoubleAnimation" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new DoubleAnimation(Host.content.createFromXaml("<DoubleAnimation />"));
    } catch (ex) {}
    if (Host.getHost)
        return DoubleAnimation.CreateNew(Host.getHost());
    return;
}
DoubleAnimation.get_FromProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("DoubleAnimation.From");
}

DoubleAnimation.get_ToProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("DoubleAnimation.To");
}

DoubleAnimation.get_ByProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("DoubleAnimation.By");
}

DoubleAnimation.prototype = new Animation;

DoubleAnimation.prototype.set_from = function(value)
{
    /// <summary>Gets or sets the animation's starting value.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.from = value;
}

DoubleAnimation.prototype.get_from = function()
{
    /// <summary>Gets or sets the animation's starting value.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.from);
}

DoubleAnimation.prototype.set_to = function(value)
{
    /// <summary>Gets or sets the animation's ending value.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.to = value;
}

DoubleAnimation.prototype.get_to = function()
{
    /// <summary>Gets or sets the animation's ending value.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.to);
}

DoubleAnimation.prototype.set_by = function(value)
{
    /// <summary>Gets or sets the total amount by which the animation changes its starting value.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.by = value;
}

DoubleAnimation.prototype.get_by = function()
{
    /// <summary>Gets or sets the total amount by which the animation changes its starting value.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.by);
}

ColorAnimation = function(ColorAnimationXamlElement) 
{
        /// <summary>Animates the value of a Color property between two target values using linear interpolation over a specified Duration.</summary>
        /// <param name="ColorAnimationXamlElement">Non strongly typed Xaml Element</param>
        this.element = ColorAnimationXamlElement;
}
ColorAnimation.createFromXaml = function(Host)
{
    /// <returns type="ColorAnimation" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new ColorAnimation(Host.content.createFromXaml("<ColorAnimation />"));
    } catch (ex) {}
    if (Host.getHost)
        return ColorAnimation.CreateNew(Host.getHost());
    return;
}
ColorAnimation.get_FromProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ColorAnimation.From");
}

ColorAnimation.get_ToProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ColorAnimation.To");
}

ColorAnimation.get_ByProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ColorAnimation.By");
}

ColorAnimation.prototype = new Animation;

ColorAnimation.prototype.set_from = function(value)
{
    /// <summary>Gets or sets the animation's starting value.</summary>
    /// <param name="value" type="Color" integer="False" />
    TypeSafety({"Color" : value});   
    this.element.from = value.element;
}

ColorAnimation.prototype.get_from = function()
{
    /// <summary>Gets or sets the animation's starting value.</summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.from);
}

ColorAnimation.prototype.set_to = function(value)
{
    /// <summary>Gets or sets the animation's ending value.</summary>
    /// <param name="value" type="Color" integer="False" />
    TypeSafety({"Color" : value});   
    this.element.to = value.element;
}

ColorAnimation.prototype.get_to = function()
{
    /// <summary>Gets or sets the animation's ending value.</summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.to);
}

ColorAnimation.prototype.set_by = function(value)
{
    /// <summary>Gets or sets the total amount by which the animation changes its starting value.</summary>
    /// <param name="value" type="Color" integer="False" />
    TypeSafety({"Color" : value});   
    this.element.by = value.element;
}

ColorAnimation.prototype.get_by = function()
{
    /// <summary>Gets or sets the total amount by which the animation changes its starting value.</summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.by);
}

PointAnimation = function(PointAnimationXamlElement) 
{
        /// <summary>Animates the value of a Point property between two target values using linear interpolation over a specified Duration.</summary>
        /// <param name="PointAnimationXamlElement">Non strongly typed Xaml Element</param>
        this.element = PointAnimationXamlElement;
}
PointAnimation.createFromXaml = function(Host)
{
    /// <returns type="PointAnimation" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new PointAnimation(Host.content.createFromXaml("<PointAnimation />"));
    } catch (ex) {}
    if (Host.getHost)
        return PointAnimation.CreateNew(Host.getHost());
    return;
}
PointAnimation.get_FromProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("PointAnimation.From");
}

PointAnimation.get_ToProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("PointAnimation.To");
}

PointAnimation.get_ByProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("PointAnimation.By");
}

PointAnimation.prototype = new Animation;

PointAnimation.prototype.set_from = function(value)
{
    /// <summary>Gets or sets the animation's starting value.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.from = value.element;
}

PointAnimation.prototype.get_from = function()
{
    /// <summary>Gets or sets the animation's starting value.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.from);
}

PointAnimation.prototype.set_to = function(value)
{
    /// <summary>Gets or sets the animation's ending value.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.to = value.element;
}

PointAnimation.prototype.get_to = function()
{
    /// <summary>Gets or sets the animation's ending value.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.to);
}

PointAnimation.prototype.set_by = function(value)
{
    /// <summary>Gets or sets the total amount by which the animation changes its starting value.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.by = value.element;
}

PointAnimation.prototype.get_by = function()
{
    /// <summary>Gets or sets the total amount by which the animation changes its starting value.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.by);
}

KeySpline = function(KeySplineXamlElement) 
{
        /// <summary>This object is used by a spline key frame to define animation progress.</summary>
        /// <param name="KeySplineXamlElement">Non strongly typed Xaml Element</param>
        this.element = KeySplineXamlElement;
}
KeySpline.createFromXaml = function(Host)
{
    /// <returns type="KeySpline" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new KeySpline(Host.content.createFromXaml("<KeySpline />"));
    } catch (ex) {}
    if (Host.getHost)
        return KeySpline.CreateNew(Host.getHost());
    return;
}
KeySpline.prototype = new DependencyObject;

KeyFrame = function(KeyFrameXamlElement) 
{
        /// <summary>Defines an animation segment with its own target value and interpolation method for an animation using keyframes.</summary>
        /// <param name="KeyFrameXamlElement">Non strongly typed Xaml Element</param>
        this.element = KeyFrameXamlElement;
}
KeyFrame.createFromXaml = function(Host)
{
    /// <returns type="KeyFrame" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new KeyFrame(Host.content.createFromXaml("<KeyFrame />"));
    } catch (ex) {}
    if (Host.getHost)
        return KeyFrame.CreateNew(Host.getHost());
    return;
}
KeyFrame.get_KeyTimeProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("KeyFrame.KeyTime");
}

KeyFrame.prototype = new DependencyObject;

KeyFrame.prototype.set_keyTime = function(value)
{
    /// <summary>Gets or sets the time at which the key frame's target Value should be reached.</summary>
    /// <param name="value" type="KeyTime" integer="False" />
    TypeSafety({"KeyTime" : value});   
    this.element.keyTime = value.element;
}

KeyFrame.prototype.get_keyTime = function()
{
    /// <summary>Gets or sets the time at which the key frame's target Value should be reached.</summary>
    /// <returns type="KeyTime" integer="False" />   
    return Convert.ToKeyTime(this.element.keyTime);
}

ColorKeyFrameCollection = function(ColorKeyFrameCollectionXamlElement) 
{
        /// <summary>Represents a collection of ColorKeyFrame objects that can be individually accessed by index.</summary>
        /// <param name="ColorKeyFrameCollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = ColorKeyFrameCollectionXamlElement;
}
ColorKeyFrameCollection.createFromXaml = function(Host)
{
    /// <returns type="ColorKeyFrameCollection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new ColorKeyFrameCollection(Host.content.createFromXaml("<ColorKeyFrameCollection />"));
    } catch (ex) {}
    if (Host.getHost)
        return ColorKeyFrameCollection.CreateNew(Host.getHost());
    return;
}
ColorKeyFrameCollection.prototype = new Collection;

ColorKeyFrameCollection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="ColorKeyFrame" integer="False" />   
    return Convert.ToColorKeyFrame(this.element.getItem(Index));
}

ColorKeyFrameCollection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="ColorKeyFrame" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"ColorKeyFrame":value});
    return (this.element.add(value.element));
}

ColorKeyFrameCollection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="ColorKeyFrame" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"ColorKeyFrame":value});
    return (this.element.contains(value.element));
}

ColorKeyFrameCollection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="ColorKeyFrame" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"ColorKeyFrame":value});
    return (this.element.indexOf(value.element));
}

ColorKeyFrameCollection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="ColorKeyFrame" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "ColorKeyFrame":value});
    return (this.element.insert(index, value.element));
}

ColorKeyFrameCollection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="ColorKeyFrame" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"ColorKeyFrame":value});
    return (this.element.remove(value.element));
}

ColorKeyFrameCollection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="ColorKeyFrame[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"ColorKeyFrame[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

DoubleKeyFrameCollection = function(DoubleKeyFrameCollectionXamlElement) 
{
        /// <summary>Represents a collection of DoubleKeyFrame objects that can be individually accessed by index.</summary>
        /// <param name="DoubleKeyFrameCollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = DoubleKeyFrameCollectionXamlElement;
}
DoubleKeyFrameCollection.createFromXaml = function(Host)
{
    /// <returns type="DoubleKeyFrameCollection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new DoubleKeyFrameCollection(Host.content.createFromXaml("<DoubleKeyFrameCollection />"));
    } catch (ex) {}
    if (Host.getHost)
        return DoubleKeyFrameCollection.CreateNew(Host.getHost());
    return;
}
DoubleKeyFrameCollection.prototype = new Collection;

DoubleKeyFrameCollection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="DoubleKeyFrame" integer="False" />   
    return Convert.ToDoubleKeyFrame(this.element.getItem(Index));
}

DoubleKeyFrameCollection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="DoubleKeyFrame" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"DoubleKeyFrame":value});
    return (this.element.add(value.element));
}

DoubleKeyFrameCollection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="DoubleKeyFrame" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"DoubleKeyFrame":value});
    return (this.element.contains(value.element));
}

DoubleKeyFrameCollection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="DoubleKeyFrame" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"DoubleKeyFrame":value});
    return (this.element.indexOf(value.element));
}

DoubleKeyFrameCollection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="DoubleKeyFrame" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "DoubleKeyFrame":value});
    return (this.element.insert(index, value.element));
}

DoubleKeyFrameCollection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="DoubleKeyFrame" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"DoubleKeyFrame":value});
    return (this.element.remove(value.element));
}

DoubleKeyFrameCollection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="DoubleKeyFrame[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"DoubleKeyFrame[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

PointKeyFrameCollection = function(PointKeyFrameCollectionXamlElement) 
{
        /// <summary>Represents a collection of PointKeyFrame objects that can be individually accessed by index.</summary>
        /// <param name="PointKeyFrameCollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = PointKeyFrameCollectionXamlElement;
}
PointKeyFrameCollection.createFromXaml = function(Host)
{
    /// <returns type="PointKeyFrameCollection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new PointKeyFrameCollection(Host.content.createFromXaml("<PointKeyFrameCollection />"));
    } catch (ex) {}
    if (Host.getHost)
        return PointKeyFrameCollection.CreateNew(Host.getHost());
    return;
}
PointKeyFrameCollection.prototype = new Collection;

PointKeyFrameCollection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="PointKeyFrame" integer="False" />   
    return Convert.ToPointKeyFrame(this.element.getItem(Index));
}

PointKeyFrameCollection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="PointKeyFrame" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"PointKeyFrame":value});
    return (this.element.add(value.element));
}

PointKeyFrameCollection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="PointKeyFrame" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"PointKeyFrame":value});
    return (this.element.contains(value.element));
}

PointKeyFrameCollection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="PointKeyFrame" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"PointKeyFrame":value});
    return (this.element.indexOf(value.element));
}

PointKeyFrameCollection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="PointKeyFrame" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "PointKeyFrame":value});
    return (this.element.insert(index, value.element));
}

PointKeyFrameCollection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="PointKeyFrame" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"PointKeyFrame":value});
    return (this.element.remove(value.element));
}

PointKeyFrameCollection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="PointKeyFrame[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"PointKeyFrame[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

DoubleAnimationUsingKeyFrames = function(DoubleAnimationUsingKeyFramesXamlElement) 
{
        /// <summary>Animates the value of a Double property along a set of KeyFrames.</summary>
        /// <param name="DoubleAnimationUsingKeyFramesXamlElement">Non strongly typed Xaml Element</param>
        this.element = DoubleAnimationUsingKeyFramesXamlElement;
}
DoubleAnimationUsingKeyFrames.createFromXaml = function(Host)
{
    /// <returns type="DoubleAnimationUsingKeyFrames" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new DoubleAnimationUsingKeyFrames(Host.content.createFromXaml("<DoubleAnimationUsingKeyFrames />"));
    } catch (ex) {}
    if (Host.getHost)
        return DoubleAnimationUsingKeyFrames.CreateNew(Host.getHost());
    return;
}
DoubleAnimationUsingKeyFrames.get_KeyFramesProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("DoubleAnimationUsingKeyFrames.KeyFrames");
}

DoubleAnimationUsingKeyFrames.prototype = new DoubleAnimation;

DoubleAnimationUsingKeyFrames.prototype.set_keyFrames = function(value)
{
    /// <summary>Gets or sets the collection of ColorKeyFrame objects that define the animation.</summary>
    /// <param name="value" type="DoubleKeyFrameCollection" integer="False" />
    TypeSafety({"DoubleKeyFrameCollection" : value});   
    this.element.keyFrames = value.element;
}

DoubleAnimationUsingKeyFrames.prototype.get_keyFrames = function()
{
    /// <summary>Gets or sets the collection of ColorKeyFrame objects that define the animation.</summary>
    /// <returns type="DoubleKeyFrameCollection" integer="False" />   
    return Convert.ToDoubleKeyFrameCollection(this.element.keyFrames);
}

DoubleKeyFrame = function(DoubleKeyFrameXamlElement) 
{
        /// <summary>Defines an animation segment with its own target value and interpolation method for a DoubleAnimationUsingKeyFrames.</summary>
        /// <param name="DoubleKeyFrameXamlElement">Non strongly typed Xaml Element</param>
        this.element = DoubleKeyFrameXamlElement;
}
DoubleKeyFrame.createFromXaml = function(Host)
{
    /// <returns type="DoubleKeyFrame" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new DoubleKeyFrame(Host.content.createFromXaml("<DoubleKeyFrame />"));
    } catch (ex) {}
    if (Host.getHost)
        return DoubleKeyFrame.CreateNew(Host.getHost());
    return;
}
DoubleKeyFrame.get_ValueProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("DoubleKeyFrame.Value");
}

DoubleKeyFrame.prototype = new KeyFrame;

DoubleKeyFrame.prototype.set_value = function(value)
{
    /// <summary>Gets or sets the key frame's target value.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.value = value;
}

DoubleKeyFrame.prototype.get_value = function()
{
    /// <summary>Gets or sets the key frame's target value.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.value);
}

DiscreteDoubleKeyFrame = function(DiscreteDoubleKeyFrameXamlElement) 
{
        /// <summary>Animates from the Double value of the previous key frame to its own Value using discrete interpolation.</summary>
        /// <param name="DiscreteDoubleKeyFrameXamlElement">Non strongly typed Xaml Element</param>
        this.element = DiscreteDoubleKeyFrameXamlElement;
}
DiscreteDoubleKeyFrame.createFromXaml = function(Host)
{
    /// <returns type="DiscreteDoubleKeyFrame" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new DiscreteDoubleKeyFrame(Host.content.createFromXaml("<DiscreteDoubleKeyFrame />"));
    } catch (ex) {}
    if (Host.getHost)
        return DiscreteDoubleKeyFrame.CreateNew(Host.getHost());
    return;
}
DiscreteDoubleKeyFrame.prototype = new DoubleKeyFrame;

LinearDoubleKeyFrame = function(LinearDoubleKeyFrameXamlElement) 
{
        /// <summary>Animates from the Double value of the previous key frame to its own Value using linear interpolation.</summary>
        /// <param name="LinearDoubleKeyFrameXamlElement">Non strongly typed Xaml Element</param>
        this.element = LinearDoubleKeyFrameXamlElement;
}
LinearDoubleKeyFrame.createFromXaml = function(Host)
{
    /// <returns type="LinearDoubleKeyFrame" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new LinearDoubleKeyFrame(Host.content.createFromXaml("<LinearDoubleKeyFrame />"));
    } catch (ex) {}
    if (Host.getHost)
        return LinearDoubleKeyFrame.CreateNew(Host.getHost());
    return;
}
LinearDoubleKeyFrame.prototype = new DoubleKeyFrame;

SplineDoubleKeyFrame = function(SplineDoubleKeyFrameXamlElement) 
{
        /// <summary>Animates from the Double value of the previous key frame to its own Value using splined interpolation.</summary>
        /// <param name="SplineDoubleKeyFrameXamlElement">Non strongly typed Xaml Element</param>
        this.element = SplineDoubleKeyFrameXamlElement;
}
SplineDoubleKeyFrame.createFromXaml = function(Host)
{
    /// <returns type="SplineDoubleKeyFrame" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new SplineDoubleKeyFrame(Host.content.createFromXaml("<SplineDoubleKeyFrame />"));
    } catch (ex) {}
    if (Host.getHost)
        return SplineDoubleKeyFrame.CreateNew(Host.getHost());
    return;
}
SplineDoubleKeyFrame.get_KeySplineProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("SplineDoubleKeyFrame.KeySpline");
}

SplineDoubleKeyFrame.prototype = new DoubleKeyFrame;

SplineDoubleKeyFrame.prototype.set_keySpline = function(value)
{
    /// <summary>Gets or sets the two control points that define animation progress for this key frame.</summary>
    /// <param name="value" type="KeySpline" integer="False" />
    TypeSafety({"KeySpline" : value});   
    this.element.keySpline = value.element;
}

SplineDoubleKeyFrame.prototype.get_keySpline = function()
{
    /// <summary>Gets or sets the two control points that define animation progress for this key frame.</summary>
    /// <returns type="KeySpline" integer="False" />   
    return Convert.ToKeySpline(this.element.keySpline);
}

ColorAnimationUsingKeyFrames = function(ColorAnimationUsingKeyFramesXamlElement) 
{
        /// <summary>Animates the value of a Color property along a set of KeyFrames over a specified Duration.</summary>
        /// <param name="ColorAnimationUsingKeyFramesXamlElement">Non strongly typed Xaml Element</param>
        this.element = ColorAnimationUsingKeyFramesXamlElement;
}
ColorAnimationUsingKeyFrames.createFromXaml = function(Host)
{
    /// <returns type="ColorAnimationUsingKeyFrames" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new ColorAnimationUsingKeyFrames(Host.content.createFromXaml("<ColorAnimationUsingKeyFrames />"));
    } catch (ex) {}
    if (Host.getHost)
        return ColorAnimationUsingKeyFrames.CreateNew(Host.getHost());
    return;
}
ColorAnimationUsingKeyFrames.get_KeyFramesProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ColorAnimationUsingKeyFrames.KeyFrames");
}

ColorAnimationUsingKeyFrames.prototype = new ColorAnimation;

ColorAnimationUsingKeyFrames.prototype.set_keyFrames = function(value)
{
    /// <summary>Gets or sets the collection of ColorKeyFrame objects that define the animation.</summary>
    /// <param name="value" type="ColorKeyFrameCollection" integer="False" />
    TypeSafety({"ColorKeyFrameCollection" : value});   
    this.element.keyFrames = value.element;
}

ColorAnimationUsingKeyFrames.prototype.get_keyFrames = function()
{
    /// <summary>Gets or sets the collection of ColorKeyFrame objects that define the animation.</summary>
    /// <returns type="ColorKeyFrameCollection" integer="False" />   
    return Convert.ToColorKeyFrameCollection(this.element.keyFrames);
}

ColorKeyFrame = function(ColorKeyFrameXamlElement) 
{
        /// <summary>Defines an animation segment with its own target value and interpolation method for a ColorAnimationUsingKeyFrames.</summary>
        /// <param name="ColorKeyFrameXamlElement">Non strongly typed Xaml Element</param>
        this.element = ColorKeyFrameXamlElement;
}
ColorKeyFrame.createFromXaml = function(Host)
{
    /// <returns type="ColorKeyFrame" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new ColorKeyFrame(Host.content.createFromXaml("<ColorKeyFrame />"));
    } catch (ex) {}
    if (Host.getHost)
        return ColorKeyFrame.CreateNew(Host.getHost());
    return;
}
ColorKeyFrame.get_ValueProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ColorKeyFrame.Value");
}

ColorKeyFrame.prototype = new KeyFrame;

ColorKeyFrame.prototype.set_value = function(value)
{
    /// <summary>Gets or sets the key frame's target value.</summary>
    /// <param name="value" type="Color" integer="False" />
    TypeSafety({"Color" : value});   
    this.element.value = value.element;
}

ColorKeyFrame.prototype.get_value = function()
{
    /// <summary>Gets or sets the key frame's target value.</summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.value);
}

DiscreteColorKeyFrame = function(DiscreteColorKeyFrameXamlElement) 
{
        /// <summary>Animates from the Color value of the previous key frame to its own Value using discrete interpolation.</summary>
        /// <param name="DiscreteColorKeyFrameXamlElement">Non strongly typed Xaml Element</param>
        this.element = DiscreteColorKeyFrameXamlElement;
}
DiscreteColorKeyFrame.createFromXaml = function(Host)
{
    /// <returns type="DiscreteColorKeyFrame" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new DiscreteColorKeyFrame(Host.content.createFromXaml("<DiscreteColorKeyFrame />"));
    } catch (ex) {}
    if (Host.getHost)
        return DiscreteColorKeyFrame.CreateNew(Host.getHost());
    return;
}
DiscreteColorKeyFrame.prototype = new ColorKeyFrame;

LinearColorKeyFrame = function(LinearColorKeyFrameXamlElement) 
{
        /// <summary>Animates from the Color value of the previous key frame to its own Value using linear interpolation.</summary>
        /// <param name="LinearColorKeyFrameXamlElement">Non strongly typed Xaml Element</param>
        this.element = LinearColorKeyFrameXamlElement;
}
LinearColorKeyFrame.createFromXaml = function(Host)
{
    /// <returns type="LinearColorKeyFrame" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new LinearColorKeyFrame(Host.content.createFromXaml("<LinearColorKeyFrame />"));
    } catch (ex) {}
    if (Host.getHost)
        return LinearColorKeyFrame.CreateNew(Host.getHost());
    return;
}
LinearColorKeyFrame.prototype = new ColorKeyFrame;

SplineColorKeyFrame = function(SplineColorKeyFrameXamlElement) 
{
        /// <summary>Animates from the Color value of the previous key frame to its own Value using splined interpolation.</summary>
        /// <param name="SplineColorKeyFrameXamlElement">Non strongly typed Xaml Element</param>
        this.element = SplineColorKeyFrameXamlElement;
}
SplineColorKeyFrame.createFromXaml = function(Host)
{
    /// <returns type="SplineColorKeyFrame" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new SplineColorKeyFrame(Host.content.createFromXaml("<SplineColorKeyFrame />"));
    } catch (ex) {}
    if (Host.getHost)
        return SplineColorKeyFrame.CreateNew(Host.getHost());
    return;
}
SplineColorKeyFrame.get_KeySplineProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("SplineColorKeyFrame.KeySpline");
}

SplineColorKeyFrame.prototype = new ColorKeyFrame;

SplineColorKeyFrame.prototype.set_keySpline = function(value)
{
    /// <summary>Gets or sets the two control points that define animation progress for this key frame.</summary>
    /// <param name="value" type="KeySpline" integer="False" />
    TypeSafety({"KeySpline" : value});   
    this.element.keySpline = value.element;
}

SplineColorKeyFrame.prototype.get_keySpline = function()
{
    /// <summary>Gets or sets the two control points that define animation progress for this key frame.</summary>
    /// <returns type="KeySpline" integer="False" />   
    return Convert.ToKeySpline(this.element.keySpline);
}

PointAnimationUsingKeyFrames = function(PointAnimationUsingKeyFramesXamlElement) 
{
        /// <summary>Animates the value of a Point property along a set of KeyFrames.</summary>
        /// <param name="PointAnimationUsingKeyFramesXamlElement">Non strongly typed Xaml Element</param>
        this.element = PointAnimationUsingKeyFramesXamlElement;
}
PointAnimationUsingKeyFrames.createFromXaml = function(Host)
{
    /// <returns type="PointAnimationUsingKeyFrames" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new PointAnimationUsingKeyFrames(Host.content.createFromXaml("<PointAnimationUsingKeyFrames />"));
    } catch (ex) {}
    if (Host.getHost)
        return PointAnimationUsingKeyFrames.CreateNew(Host.getHost());
    return;
}
PointAnimationUsingKeyFrames.get_KeyFramesProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("PointAnimationUsingKeyFrames.KeyFrames");
}

PointAnimationUsingKeyFrames.prototype = new PointAnimation;

PointAnimationUsingKeyFrames.prototype.set_keyFrames = function(value)
{
    /// <summary>Gets or sets the collection of ColorKeyFrame objects that define the animation.</summary>
    /// <param name="value" type="PointKeyFrameCollection" integer="False" />
    TypeSafety({"PointKeyFrameCollection" : value});   
    this.element.keyFrames = value.element;
}

PointAnimationUsingKeyFrames.prototype.get_keyFrames = function()
{
    /// <summary>Gets or sets the collection of ColorKeyFrame objects that define the animation.</summary>
    /// <returns type="PointKeyFrameCollection" integer="False" />   
    return Convert.ToPointKeyFrameCollection(this.element.keyFrames);
}

PointKeyFrame = function(PointKeyFrameXamlElement) 
{
        /// <summary>Defines an animation segment with its own target value and interpolation method for a PointAnimationUsingKeyFrames.</summary>
        /// <param name="PointKeyFrameXamlElement">Non strongly typed Xaml Element</param>
        this.element = PointKeyFrameXamlElement;
}
PointKeyFrame.createFromXaml = function(Host)
{
    /// <returns type="PointKeyFrame" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new PointKeyFrame(Host.content.createFromXaml("<PointKeyFrame />"));
    } catch (ex) {}
    if (Host.getHost)
        return PointKeyFrame.CreateNew(Host.getHost());
    return;
}
PointKeyFrame.get_ValueProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("PointKeyFrame.Value");
}

PointKeyFrame.prototype = new KeyFrame;

PointKeyFrame.prototype.set_value = function(value)
{
    /// <summary>Gets or sets the key frame's target value.</summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.value = value.element;
}

PointKeyFrame.prototype.get_value = function()
{
    /// <summary>Gets or sets the key frame's target value.</summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.value);
}

DiscretePointKeyFrame = function(DiscretePointKeyFrameXamlElement) 
{
        /// <summary>Animates from the Point value of the previous key frame to its own Value using discrete interpolation.</summary>
        /// <param name="DiscretePointKeyFrameXamlElement">Non strongly typed Xaml Element</param>
        this.element = DiscretePointKeyFrameXamlElement;
}
DiscretePointKeyFrame.createFromXaml = function(Host)
{
    /// <returns type="DiscretePointKeyFrame" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new DiscretePointKeyFrame(Host.content.createFromXaml("<DiscretePointKeyFrame />"));
    } catch (ex) {}
    if (Host.getHost)
        return DiscretePointKeyFrame.CreateNew(Host.getHost());
    return;
}
DiscretePointKeyFrame.prototype = new PointKeyFrame;

LinearPointKeyFrame = function(LinearPointKeyFrameXamlElement) 
{
        /// <summary>Animates from the Point value of the previous key frame to its own Value using linear interpolation.</summary>
        /// <param name="LinearPointKeyFrameXamlElement">Non strongly typed Xaml Element</param>
        this.element = LinearPointKeyFrameXamlElement;
}
LinearPointKeyFrame.createFromXaml = function(Host)
{
    /// <returns type="LinearPointKeyFrame" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new LinearPointKeyFrame(Host.content.createFromXaml("<LinearPointKeyFrame />"));
    } catch (ex) {}
    if (Host.getHost)
        return LinearPointKeyFrame.CreateNew(Host.getHost());
    return;
}
LinearPointKeyFrame.prototype = new PointKeyFrame;

SplinePointKeyFrame = function(SplinePointKeyFrameXamlElement) 
{
        /// <summary>Animates from the Point value of the previous key frame to its own Value using splined interpolation.</summary>
        /// <param name="SplinePointKeyFrameXamlElement">Non strongly typed Xaml Element</param>
        this.element = SplinePointKeyFrameXamlElement;
}
SplinePointKeyFrame.createFromXaml = function(Host)
{
    /// <returns type="SplinePointKeyFrame" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new SplinePointKeyFrame(Host.content.createFromXaml("<SplinePointKeyFrame />"));
    } catch (ex) {}
    if (Host.getHost)
        return SplinePointKeyFrame.CreateNew(Host.getHost());
    return;
}
SplinePointKeyFrame.get_KeySplineProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("SplinePointKeyFrame.KeySpline");
}

SplinePointKeyFrame.prototype = new PointKeyFrame;

SplinePointKeyFrame.prototype.set_keySpline = function(value)
{
    /// <summary>Gets or sets the two control points that define animation progress for this key frame.</summary>
    /// <param name="value" type="KeySpline" integer="False" />
    TypeSafety({"KeySpline" : value});   
    this.element.keySpline = value.element;
}

SplinePointKeyFrame.prototype.get_keySpline = function()
{
    /// <summary>Gets or sets the two control points that define animation progress for this key frame.</summary>
    /// <returns type="KeySpline" integer="False" />   
    return Convert.ToKeySpline(this.element.keySpline);
}

TimelineMarker = function(TimelineMarkerXamlElement) 
{
        /// <summary>Represents metadata associated with a specific point in a media file.</summary>
        /// <param name="TimelineMarkerXamlElement">Non strongly typed Xaml Element</param>
        this.element = TimelineMarkerXamlElement;
}
TimelineMarker.createFromXaml = function(Host)
{
    /// <returns type="TimelineMarker" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new TimelineMarker(Host.content.createFromXaml("<TimelineMarker />"));
    } catch (ex) {}
    if (Host.getHost)
        return TimelineMarker.CreateNew(Host.getHost());
    return;
}
TimelineMarker.get_TimeProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TimelineMarker.Time");
}

TimelineMarker.get_TypeProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TimelineMarker.Type");
}

TimelineMarker.get_TextProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TimelineMarker.Text");
}

TimelineMarker.prototype = new DependencyObject;

TimelineMarker.prototype.set_time = function(value)
{
    /// <summary>Gets or sets the time at which the key frame's target Value should be reached.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.time = value;
}

TimelineMarker.prototype.get_time = function()
{
    /// <summary>Gets or sets the time at which the key frame's target Value should be reached.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.time);
}

TimelineMarker.prototype.set_type = function(value)
{
    /// <summary>Gets the ErrorType of the error associated with the event.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.type = value;
}

TimelineMarker.prototype.get_type = function()
{
    /// <summary>Gets the ErrorType of the error associated with the event.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.type);
}

TimelineMarker.prototype.set_text = function(value)
{
    /// <summary>Gets downloaded data from a successful download request.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.text = value;
}

TimelineMarker.prototype.get_text = function()
{
    /// <summary>Gets downloaded data from a successful download request.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.text);
}

TimelineMarkerCollection = function(TimelineMarkerCollectionXamlElement) 
{
        /// <summary>Represents a collection of TimelineMarker objects.</summary>
        /// <param name="TimelineMarkerCollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = TimelineMarkerCollectionXamlElement;
}
TimelineMarkerCollection.createFromXaml = function(Host)
{
    /// <returns type="TimelineMarkerCollection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new TimelineMarkerCollection(Host.content.createFromXaml("<TimelineMarkerCollection />"));
    } catch (ex) {}
    if (Host.getHost)
        return TimelineMarkerCollection.CreateNew(Host.getHost());
    return;
}
TimelineMarkerCollection.prototype = new Collection;

TimelineMarkerCollection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="TimelineMarker" integer="False" />   
    return Convert.ToTimelineMarker(this.element.getItem(Index));
}

TimelineMarkerCollection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="TimelineMarker" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"TimelineMarker":value});
    return (this.element.add(value.element));
}

TimelineMarkerCollection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="TimelineMarker" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"TimelineMarker":value});
    return (this.element.contains(value.element));
}

TimelineMarkerCollection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="TimelineMarker" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"TimelineMarker":value});
    return (this.element.indexOf(value.element));
}

TimelineMarkerCollection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="TimelineMarker" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "TimelineMarker":value});
    return (this.element.insert(index, value.element));
}

TimelineMarkerCollection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="TimelineMarker" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"TimelineMarker":value});
    return (this.element.remove(value.element));
}

TimelineMarkerCollection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="TimelineMarker[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"TimelineMarker[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

MouseEventHandler = function(MouseEventHandlerXamlElement) 
{
        /// <summary></summary>
        /// <param name="MouseEventHandlerXamlElement">Non strongly typed Xaml Element</param>
        this.element = MouseEventHandlerXamlElement;
}
MouseEventHandler.prototype.get_method = function()
{
    /// <summary>Gets or sets the type of spread method that specifies how to draw a gradient that starts or ends inside the bounds of the object to be painted.</summary>
    /// <returns type="MethodInfo" integer="False" />   
    return (this.element.method);
}

MouseEventHandler.prototype.get_target = function()
{
    /// <summary></summary>
    /// <returns type="Object" integer="False" />   
    return (this.element.target);
}

MouseEventHandler.prototype.invoke = function(sender, e)
{
     /// <summary></summary>
    /// <param name="sender" type="Object" integer="False" ></param>   
    /// <param name="e" type="MouseEventArgs" integer="False" ></param>   
    TypeSafety({"Object":sender, "MouseEventArgs":e});
    return (this.element.invoke(sender, e.element));
}

MouseEventHandler.prototype.beginInvoke = function(sender, e, callback, object)
{
     /// <summary></summary>
    /// <param name="sender" type="Object" integer="False" ></param>   
    /// <param name="e" type="MouseEventArgs" integer="False" ></param>   
    /// <param name="callback" type="AsyncCallback" integer="False" ></param>   
    /// <param name="object" type="Object" integer="False" ></param>   
    /// <returns type="IAsyncResult" integer="False" />   
    TypeSafety({"Object":sender, "MouseEventArgs":e, "AsyncCallback":callback, "Object":object});
    return (this.element.beginInvoke(sender, e.element, callback, object));
}

MouseEventHandler.prototype.endInvoke = function(result)
{
     /// <summary></summary>
    /// <param name="result" type="IAsyncResult" integer="False" ></param>   
    TypeSafety({"IAsyncResult":result});
    return (this.element.endInvoke(result));
}

MouseEventHandler.prototype.getObjectData = function(info, context)
{
     /// <summary></summary>
    /// <param name="info" type="SerializationInfo" integer="False" ></param>   
    /// <param name="context" type="StreamingContext" integer="False" ></param>   
    TypeSafety({"SerializationInfo":info, "StreamingContext":context});
    return (this.element.getObjectData(info, context));
}

MouseEventHandler.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

MouseEventHandler.prototype.getInvocationList = function()
{
     /// <summary></summary>
    /// <returns type="Delegate[]" integer="False" />   
    TypeSafety({});
    return (this.element.getInvocationList());
}

MouseEventHandler.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

MouseEventHandler.prototype.dynamicInvoke = function(args)
{
     /// <summary></summary>
    /// <param name="args" type="Object[]" integer="False" ></param>   
    /// <returns type="Object" integer="False" />   
    TypeSafety({"Object[]":args});
    return (this.element.dynamicInvoke(args));
}

MouseEventHandler.prototype.clone = function()
{
     /// <summary></summary>
    /// <returns type="Object" integer="False" />   
    TypeSafety({});
    return (this.element.clone());
}

MouseEventHandler.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

MouseEventHandler.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

MouseEventHandler.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

KeyboardEventHandler = function(KeyboardEventHandlerXamlElement) 
{
        /// <summary></summary>
        /// <param name="KeyboardEventHandlerXamlElement">Non strongly typed Xaml Element</param>
        this.element = KeyboardEventHandlerXamlElement;
}
KeyboardEventHandler.prototype.get_method = function()
{
    /// <summary>Gets or sets the type of spread method that specifies how to draw a gradient that starts or ends inside the bounds of the object to be painted.</summary>
    /// <returns type="MethodInfo" integer="False" />   
    return (this.element.method);
}

KeyboardEventHandler.prototype.get_target = function()
{
    /// <summary></summary>
    /// <returns type="Object" integer="False" />   
    return (this.element.target);
}

KeyboardEventHandler.prototype.invoke = function(sender, e)
{
     /// <summary></summary>
    /// <param name="sender" type="Object" integer="False" ></param>   
    /// <param name="e" type="KeyboardEventArgs" integer="False" ></param>   
    TypeSafety({"Object":sender, "KeyboardEventArgs":e});
    return (this.element.invoke(sender, e.element));
}

KeyboardEventHandler.prototype.beginInvoke = function(sender, e, callback, object)
{
     /// <summary></summary>
    /// <param name="sender" type="Object" integer="False" ></param>   
    /// <param name="e" type="KeyboardEventArgs" integer="False" ></param>   
    /// <param name="callback" type="AsyncCallback" integer="False" ></param>   
    /// <param name="object" type="Object" integer="False" ></param>   
    /// <returns type="IAsyncResult" integer="False" />   
    TypeSafety({"Object":sender, "KeyboardEventArgs":e, "AsyncCallback":callback, "Object":object});
    return (this.element.beginInvoke(sender, e.element, callback, object));
}

KeyboardEventHandler.prototype.endInvoke = function(result)
{
     /// <summary></summary>
    /// <param name="result" type="IAsyncResult" integer="False" ></param>   
    TypeSafety({"IAsyncResult":result});
    return (this.element.endInvoke(result));
}

KeyboardEventHandler.prototype.getObjectData = function(info, context)
{
     /// <summary></summary>
    /// <param name="info" type="SerializationInfo" integer="False" ></param>   
    /// <param name="context" type="StreamingContext" integer="False" ></param>   
    TypeSafety({"SerializationInfo":info, "StreamingContext":context});
    return (this.element.getObjectData(info, context));
}

KeyboardEventHandler.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

KeyboardEventHandler.prototype.getInvocationList = function()
{
     /// <summary></summary>
    /// <returns type="Delegate[]" integer="False" />   
    TypeSafety({});
    return (this.element.getInvocationList());
}

KeyboardEventHandler.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

KeyboardEventHandler.prototype.dynamicInvoke = function(args)
{
     /// <summary></summary>
    /// <param name="args" type="Object[]" integer="False" ></param>   
    /// <returns type="Object" integer="False" />   
    TypeSafety({"Object[]":args});
    return (this.element.dynamicInvoke(args));
}

KeyboardEventHandler.prototype.clone = function()
{
     /// <summary></summary>
    /// <returns type="Object" integer="False" />   
    TypeSafety({});
    return (this.element.clone());
}

KeyboardEventHandler.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

KeyboardEventHandler.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

KeyboardEventHandler.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

TimelineMarkerEventHandler = function(TimelineMarkerEventHandlerXamlElement) 
{
        /// <summary></summary>
        /// <param name="TimelineMarkerEventHandlerXamlElement">Non strongly typed Xaml Element</param>
        this.element = TimelineMarkerEventHandlerXamlElement;
}
TimelineMarkerEventHandler.prototype.get_method = function()
{
    /// <summary>Gets or sets the type of spread method that specifies how to draw a gradient that starts or ends inside the bounds of the object to be painted.</summary>
    /// <returns type="MethodInfo" integer="False" />   
    return (this.element.method);
}

TimelineMarkerEventHandler.prototype.get_target = function()
{
    /// <summary></summary>
    /// <returns type="Object" integer="False" />   
    return (this.element.target);
}

TimelineMarkerEventHandler.prototype.invoke = function(sender, e)
{
     /// <summary></summary>
    /// <param name="sender" type="Object" integer="False" ></param>   
    /// <param name="e" type="TimelineMarkerEventArgs" integer="False" ></param>   
    TypeSafety({"Object":sender, "TimelineMarkerEventArgs":e});
    return (this.element.invoke(sender, e.element));
}

TimelineMarkerEventHandler.prototype.beginInvoke = function(sender, e, callback, object)
{
     /// <summary></summary>
    /// <param name="sender" type="Object" integer="False" ></param>   
    /// <param name="e" type="TimelineMarkerEventArgs" integer="False" ></param>   
    /// <param name="callback" type="AsyncCallback" integer="False" ></param>   
    /// <param name="object" type="Object" integer="False" ></param>   
    /// <returns type="IAsyncResult" integer="False" />   
    TypeSafety({"Object":sender, "TimelineMarkerEventArgs":e, "AsyncCallback":callback, "Object":object});
    return (this.element.beginInvoke(sender, e.element, callback, object));
}

TimelineMarkerEventHandler.prototype.endInvoke = function(result)
{
     /// <summary></summary>
    /// <param name="result" type="IAsyncResult" integer="False" ></param>   
    TypeSafety({"IAsyncResult":result});
    return (this.element.endInvoke(result));
}

TimelineMarkerEventHandler.prototype.getObjectData = function(info, context)
{
     /// <summary></summary>
    /// <param name="info" type="SerializationInfo" integer="False" ></param>   
    /// <param name="context" type="StreamingContext" integer="False" ></param>   
    TypeSafety({"SerializationInfo":info, "StreamingContext":context});
    return (this.element.getObjectData(info, context));
}

TimelineMarkerEventHandler.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

TimelineMarkerEventHandler.prototype.getInvocationList = function()
{
     /// <summary></summary>
    /// <returns type="Delegate[]" integer="False" />   
    TypeSafety({});
    return (this.element.getInvocationList());
}

TimelineMarkerEventHandler.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

TimelineMarkerEventHandler.prototype.dynamicInvoke = function(args)
{
     /// <summary></summary>
    /// <param name="args" type="Object[]" integer="False" ></param>   
    /// <returns type="Object" integer="False" />   
    TypeSafety({"Object[]":args});
    return (this.element.dynamicInvoke(args));
}

TimelineMarkerEventHandler.prototype.clone = function()
{
     /// <summary></summary>
    /// <returns type="Object" integer="False" />   
    TypeSafety({});
    return (this.element.clone());
}

TimelineMarkerEventHandler.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

TimelineMarkerEventHandler.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

TimelineMarkerEventHandler.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

Cursors = function(CursorsXamlElement) 
{
        /// <summary></summary>
        /// <param name="CursorsXamlElement">Non strongly typed Xaml Element</param>
        this.element = CursorsXamlElement;
}
Cursors.get_Default = function()
{
    /// <returns type="Cursors" />
    return Convert.ToCursors("Default");
}

Cursors.is_Default = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="Cursors" />
    return valueToCompare.element == "Default";
}

Cursors.get_Arrow = function()
{
    /// <returns type="Cursors" />
    return Convert.ToCursors("Arrow");
}

Cursors.is_Arrow = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="Cursors" />
    return valueToCompare.element == "Arrow";
}

Cursors.get_Hand = function()
{
    /// <returns type="Cursors" />
    return Convert.ToCursors("Hand");
}

Cursors.is_Hand = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="Cursors" />
    return valueToCompare.element == "Hand";
}

Cursors.get_Wait = function()
{
    /// <returns type="Cursors" />
    return Convert.ToCursors("Wait");
}

Cursors.is_Wait = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="Cursors" />
    return valueToCompare.element == "Wait";
}

Cursors.get_IBeam = function()
{
    /// <returns type="Cursors" />
    return Convert.ToCursors("IBeam");
}

Cursors.is_IBeam = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="Cursors" />
    return valueToCompare.element == "IBeam";
}

Cursors.get_Stylus = function()
{
    /// <returns type="Cursors" />
    return Convert.ToCursors("Stylus");
}

Cursors.is_Stylus = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="Cursors" />
    return valueToCompare.element == "Stylus";
}

Cursors.get_Eraser = function()
{
    /// <returns type="Cursors" />
    return Convert.ToCursors("Eraser");
}

Cursors.is_Eraser = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="Cursors" />
    return valueToCompare.element == "Eraser";
}

Cursors.get_None = function()
{
    /// <returns type="Cursors" />
    return Convert.ToCursors("None");
}

Cursors.is_None = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="Cursors" />
    return valueToCompare.element == "None";
}

Cursors.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

Cursors.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

Cursors.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

Cursors.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

Cursors.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

Cursors.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

Cursors.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

Cursors.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

Cursors.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

Cursors.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

TabletDeviceType = function(TabletDeviceTypeXamlElement) 
{
        /// <summary></summary>
        /// <param name="TabletDeviceTypeXamlElement">Non strongly typed Xaml Element</param>
        this.element = TabletDeviceTypeXamlElement;
}
TabletDeviceType.get_Mouse = function()
{
    /// <returns type="TabletDeviceType" />
    return Convert.ToTabletDeviceType("Mouse");
}

TabletDeviceType.is_Mouse = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="TabletDeviceType" />
    return valueToCompare.element == "Mouse";
}

TabletDeviceType.get_Stylus = function()
{
    /// <returns type="TabletDeviceType" />
    return Convert.ToTabletDeviceType("Stylus");
}

TabletDeviceType.is_Stylus = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="TabletDeviceType" />
    return valueToCompare.element == "Stylus";
}

TabletDeviceType.get_Touch = function()
{
    /// <returns type="TabletDeviceType" />
    return Convert.ToTabletDeviceType("Touch");
}

TabletDeviceType.is_Touch = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="TabletDeviceType" />
    return valueToCompare.element == "Touch";
}

TabletDeviceType.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

TabletDeviceType.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

TabletDeviceType.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

TabletDeviceType.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

TabletDeviceType.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

TabletDeviceType.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

TabletDeviceType.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

TabletDeviceType.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

TabletDeviceType.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

TabletDeviceType.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

StylusPoint = function(StylusPointXamlElement) 
{
        /// <summary>Represents a single point collected while the user is inking with the stylus or mouse.</summary>
        /// <param name="StylusPointXamlElement">Non strongly typed Xaml Element</param>
        this.element = StylusPointXamlElement;
}
StylusPoint.createFromXaml = function(Host)
{
    /// <returns type="StylusPoint" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new StylusPoint(Host.content.createFromXaml("<StylusPoint />"));
    } catch (ex) {}
    if (Host.getHost)
        return StylusPoint.CreateNew(Host.getHost());
    return;
}
StylusPoint.get_XProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("StylusPoint.X");
}

StylusPoint.get_YProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("StylusPoint.Y");
}

StylusPoint.get_PressureFactorProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("StylusPoint.PressureFactor");
}

StylusPoint.prototype = new DependencyObject;

StylusPoint.prototype.set_x = function(value)
{
    /// <summary>Gets or sets the x-radius value of the EllipseGeometry.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.x = value;
}

StylusPoint.prototype.get_x = function()
{
    /// <summary>Gets or sets the x-radius value of the EllipseGeometry.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.x);
}

StylusPoint.prototype.set_y = function(value)
{
    /// <summary>Gets or sets the total amount by which the animation changes its starting value.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.y = value;
}

StylusPoint.prototype.get_y = function()
{
    /// <summary>Gets or sets the total amount by which the animation changes its starting value.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.y);
}

StylusPoint.prototype.set_pressureFactor = function(value)
{
    /// <summary>The pressure of the stylus on the screen.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.pressureFactor = value;
}

StylusPoint.prototype.get_pressureFactor = function()
{
    /// <summary>The pressure of the stylus on the screen.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.pressureFactor);
}

StylusPointCollection = function(StylusPointCollectionXamlElement) 
{
        /// <summary>Represents a set of related StylusPoint objects.</summary>
        /// <param name="StylusPointCollectionXamlElement">Non strongly typed Xaml Element</param>
        this.element = StylusPointCollectionXamlElement;
}
StylusPointCollection.createFromXaml = function(Host)
{
    /// <returns type="StylusPointCollection" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new StylusPointCollection(Host.content.createFromXaml("<StylusPointCollection />"));
    } catch (ex) {}
    if (Host.getHost)
        return StylusPointCollection.CreateNew(Host.getHost());
    return;
}
StylusPointCollection.prototype = new Collection;

StylusPointCollection.prototype.getItem = function(Index)
{
    /// <summary>Indexer</summary>
    /// <param name="Index" type="Number" integer="true" />
    /// <returns type="StylusPoint" integer="False" />   
    return Convert.ToStylusPoint(this.element.getItem(Index));
}

StylusPointCollection.prototype.addStylusPoints = function(stylusPointCollection)
{
     /// <summary>Adds a collection of StylusPoint objects to the collection.</summary>
    /// <param name="stylusPointCollection" type="StylusPointCollection" integer="False" >The collection of StylusPoint objects to add to the collection.</param>   
    /// <returns type="Double" integer="False" />   
    TypeSafety({"StylusPointCollection":stylusPointCollection});
    return (this.element.addStylusPoints(stylusPointCollection.element));
}

StylusPointCollection.prototype.add = function(value)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="value" type="StylusPoint" integer="False" >The object to add to the collection.</param>   
    TypeSafety({"StylusPoint":value});
    return (this.element.add(value.element));
}

StylusPointCollection.prototype.contains = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="StylusPoint" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"StylusPoint":value});
    return (this.element.contains(value.element));
}

StylusPointCollection.prototype.indexOf = function(value)
{
     /// <summary></summary>
    /// <param name="value" type="StylusPoint" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"StylusPoint":value});
    return (this.element.indexOf(value.element));
}

StylusPointCollection.prototype.insert = function(index, value)
{
     /// <summary>Inserts an object into the collection at the specified index.</summary>
    /// <param name="index" type="Number" integer="True" >The index at which the object should be inserted.</param>   
    /// <param name="value" type="StylusPoint" integer="False" >The object to insert into the collection.</param>   
    TypeSafety({"Number":index, "StylusPoint":value});
    return (this.element.insert(index, value.element));
}

StylusPointCollection.prototype.remove = function(value)
{
     /// <summary>Removes the specified object from the collection.</summary>
    /// <param name="value" type="StylusPoint" integer="False" >The object to remove from the collection.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"StylusPoint":value});
    return (this.element.remove(value.element));
}

StylusPointCollection.prototype.copyTo = function(array, index)
{
     /// <summary></summary>
    /// <param name="array" type="StylusPoint[]" integer="False" ></param>   
    /// <param name="index" type="Number" integer="True" ></param>   
    TypeSafety({"StylusPoint[]":array, "Number":index});
    return (this.element.copyTo(array, index));
}

MouseEventArgs = function(MouseEventArgsXamlElement) 
{
        /// <summary>Provides data for mouse related events.</summary>
        /// <param name="MouseEventArgsXamlElement">Non strongly typed Xaml Element</param>
        this.element = MouseEventArgsXamlElement;
}
MouseEventArgs.prototype.set_shift = function(value)
{
    /// <summary>Gets a value specifying whether the Shift key was down when the event occurred.</summary>
    /// <param name="value" type="Boolean" integer="False" />
    TypeSafety({"Boolean" : value});   
    this.element.shift = value;
}

MouseEventArgs.prototype.get_shift = function()
{
    /// <summary>Gets a value specifying whether the Shift key was down when the event occurred.</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.shift);
}

MouseEventArgs.prototype.set_ctrl = function(value)
{
    /// <summary>Gets a value specifying whether the control (CTRL) key was down when the event occurred.</summary>
    /// <param name="value" type="Boolean" integer="False" />
    TypeSafety({"Boolean" : value});   
    this.element.ctrl = value;
}

MouseEventArgs.prototype.get_ctrl = function()
{
    /// <summary>Gets a value specifying whether the control (CTRL) key was down when the event occurred.</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.ctrl);
}

MouseEventArgs.prototype.getPosition = function(uiElement)
{
     /// <summary>Gets the x- and y-coordinates of the mouse pointer position.</summary>
    /// <param name="uiElement" type="UIElement" integer="False" >Any UIElement-derived object that is contained by the Silverlight plugin. The returned mouse pointer position is relative to element. To specify the object relative to the plugin, set the element parameter to null.</param>   
    /// <returns type="Point" integer="False" />   
    TypeSafety({"UIElement":uiElement});
    return Convert.ToPoint(this.element.getPosition(uiElement.element));
}

MouseEventArgs.prototype.getStylusInfo = function()
{
     /// <summary>Returns a StylusInfo object which gives information about the state of the Stylus.</summary>
    /// <returns type="StylusInfo" integer="False" />   
    TypeSafety({});
    return Convert.ToStylusInfo(this.element.getStylusInfo());
}

MouseEventArgs.prototype.getStylusPoints = function(uiElement)
{
     /// <summary>Returns a clone of the stylus points collected since the last mouse event.</summary>
    /// <param name="uiElement" type="UIElement" integer="False" >The coordinats of the StylusPoints that are returned are relative to the InkPresenter that is passed into the method.</param>   
    /// <returns type="StylusPointCollection" integer="False" />   
    TypeSafety({"UIElement":uiElement});
    return Convert.ToStylusPointCollection(this.element.getStylusPoints(uiElement.element));
}

MouseEventArgs.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

MouseEventArgs.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

MouseEventArgs.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

MouseEventArgs.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

MouseEventArgs.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

KeyboardEventArgs = function(KeyboardEventArgsXamlElement) 
{
        /// <summary>Provides data for the KeyUp and KeyDown events.</summary>
        /// <param name="KeyboardEventArgsXamlElement">Non strongly typed Xaml Element</param>
        this.element = KeyboardEventArgsXamlElement;
}
KeyboardEventArgs.prototype.set_key = function(value)
{
    /// <summary>Gets the keyboard key associated with the event.</summary>
    /// <param name="value" type="Number" integer="True" />
    TypeSafety({"Number" : value});   
    this.element.key = value;
}

KeyboardEventArgs.prototype.get_key = function()
{
    /// <summary>Gets the keyboard key associated with the event.</summary>
    /// <returns type="Number" integer="True" />   
    return (this.element.key);
}

KeyboardEventArgs.prototype.set_platformKeyCode = function(value)
{
    /// <summary>Gets a value representing the platform key associated with the event.</summary>
    /// <param name="value" type="Number" integer="True" />
    TypeSafety({"Number" : value});   
    this.element.platformKeyCode = value;
}

KeyboardEventArgs.prototype.get_platformKeyCode = function()
{
    /// <summary>Gets a value representing the platform key associated with the event.</summary>
    /// <returns type="Number" integer="True" />   
    return (this.element.platformKeyCode);
}

KeyboardEventArgs.prototype.set_shift = function(value)
{
    /// <summary>Gets a value specifying whether the Shift key was down when the event occurred.</summary>
    /// <param name="value" type="Boolean" integer="False" />
    TypeSafety({"Boolean" : value});   
    this.element.shift = value;
}

KeyboardEventArgs.prototype.get_shift = function()
{
    /// <summary>Gets a value specifying whether the Shift key was down when the event occurred.</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.shift);
}

KeyboardEventArgs.prototype.set_ctrl = function(value)
{
    /// <summary>Gets a value specifying whether the control (CTRL) key was down when the event occurred.</summary>
    /// <param name="value" type="Boolean" integer="False" />
    TypeSafety({"Boolean" : value});   
    this.element.ctrl = value;
}

KeyboardEventArgs.prototype.get_ctrl = function()
{
    /// <summary>Gets a value specifying whether the control (CTRL) key was down when the event occurred.</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.ctrl);
}

KeyboardEventArgs.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

KeyboardEventArgs.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

KeyboardEventArgs.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

KeyboardEventArgs.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

KeyboardEventArgs.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

TimelineMarkerEventArgs = function(TimelineMarkerEventArgsXamlElement) 
{
        /// <summary>Contains arguments for the MediaElement.MarkerReached event.</summary>
        /// <param name="TimelineMarkerEventArgsXamlElement">Non strongly typed Xaml Element</param>
        this.element = TimelineMarkerEventArgsXamlElement;
}
TimelineMarkerEventArgs.prototype.set_marker = function(value)
{
    /// <summary>Gets the TimelineMarker that triggered this event.</summary>
    /// <param name="value" type="TimelineMarker" integer="False" />
    TypeSafety({"TimelineMarker" : value});   
    this.element.marker = value.element;
}

TimelineMarkerEventArgs.prototype.get_marker = function()
{
    /// <summary>Gets the TimelineMarker that triggered this event.</summary>
    /// <returns type="TimelineMarker" integer="False" />   
    return Convert.ToTimelineMarker(this.element.marker);
}

TimelineMarkerEventArgs.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

TimelineMarkerEventArgs.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

TimelineMarkerEventArgs.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

TimelineMarkerEventArgs.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

TimelineMarkerEventArgs.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

StylusInfo = function(StylusInfoXamlElement) 
{
        /// <summary>Represents information about the state of the stylus.</summary>
        /// <param name="StylusInfoXamlElement">Non strongly typed Xaml Element</param>
        this.element = StylusInfoXamlElement;
}
StylusInfo.createFromXaml = function(Host)
{
    /// <returns type="StylusInfo" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new StylusInfo(Host.content.createFromXaml("<StylusInfo />"));
    } catch (ex) {}
    if (Host.getHost)
        return StylusInfo.CreateNew(Host.getHost());
    return;
}
StylusInfo.get_DeviceTypeProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("StylusInfo.DeviceType");
}

StylusInfo.get_IsInvertedProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("StylusInfo.IsInverted");
}

StylusInfo.prototype = new DependencyObject;

StylusInfo.prototype.set_deviceType = function(value)
{
    /// <summary>Indicates if the stylus represents mouse, stylus, or touch input.</summary>
    /// <param name="value" type="TabletDeviceType" integer="False" />
    TypeSafety({"TabletDeviceType" : value});   
    this.element.deviceType = value.element;
}

StylusInfo.prototype.get_deviceType = function()
{
    /// <summary>Indicates if the stylus represents mouse, stylus, or touch input.</summary>
    /// <returns type="TabletDeviceType" integer="False" />   
    return Convert.ToTabletDeviceType(this.element.deviceType);
}

StylusInfo.prototype.set_isInverted = function(value)
{
    /// <summary>Specifies whether the stylus is inverted.</summary>
    /// <param name="value" type="Boolean" integer="False" />
    TypeSafety({"Boolean" : value});   
    this.element.isInverted = value;
}

StylusInfo.prototype.get_isInverted = function()
{
    /// <summary>Specifies whether the stylus is inverted.</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.isInverted);
}

Shape = function(ShapeXamlElement) 
{
        /// <summary>Provides a base class for shape elements, such as Ellipse, Polygon, and Rectangle.</summary>
        /// <param name="ShapeXamlElement">Non strongly typed Xaml Element</param>
        this.element = ShapeXamlElement;
}
Shape.createFromXaml = function(Host)
{
    /// <returns type="Shape" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Shape(Host.content.createFromXaml("<Shape />"));
    } catch (ex) {}
    if (Host.getHost)
        return Shape.CreateNew(Host.getHost());
    return;
}
Shape.get_FillProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Shape.Fill");
}

Shape.get_StrokeProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Shape.Stroke");
}

Shape.get_StrokeMiterLimitProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Shape.StrokeMiterLimit");
}

Shape.get_StrokeThicknessProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Shape.StrokeThickness");
}

Shape.get_StrokeStartLineCapProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Shape.StrokeStartLineCap");
}

Shape.get_StrokeEndLineCapProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Shape.StrokeEndLineCap");
}

Shape.get_StrokeLineJoinProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Shape.StrokeLineJoin");
}

Shape.get_StrokeDashOffsetProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Shape.StrokeDashOffset");
}

Shape.get_StrokeDashCapProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Shape.StrokeDashCap");
}

Shape.get_StrokeDashArrayProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Shape.StrokeDashArray");
}

Shape.get_StretchProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Shape.Stretch");
}

Shape.prototype = new FrameworkElement;

Shape.prototype.set_fill = function(value)
{
    /// <summary>Gets the sets the Brush that is used for the fill of the Glyphs.</summary>
    /// <param name="value" type="Brush" integer="False" />
    TypeSafety({"Brush" : value});   
    this.element.fill = value.element;
}

Shape.prototype.get_fill = function()
{
    /// <summary>Gets the sets the Brush that is used for the fill of the Glyphs.</summary>
    /// <returns type="Brush" integer="False" />   
    return Convert.ToBrush(this.element.fill);
}

Shape.prototype.set_stroke = function(value)
{
    /// <summary>Gets or sets the Brush that specifies how to paint the Shape outline.</summary>
    /// <param name="value" type="Brush" integer="False" />
    TypeSafety({"Brush" : value});   
    this.element.stroke = value.element;
}

Shape.prototype.get_stroke = function()
{
    /// <summary>Gets or sets the Brush that specifies how to paint the Shape outline.</summary>
    /// <returns type="Brush" integer="False" />   
    return Convert.ToBrush(this.element.stroke);
}

Shape.prototype.set_strokeMiterLimit = function(value)
{
    /// <summary>Gets or sets a limit on the ratio of the miter length to half the StrokeThickness of a Shape element.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.strokeMiterLimit = value;
}

Shape.prototype.get_strokeMiterLimit = function()
{
    /// <summary>Gets or sets a limit on the ratio of the miter length to half the StrokeThickness of a Shape element.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.strokeMiterLimit);
}

Shape.prototype.set_strokeThickness = function(value)
{
    /// <summary>Gets or sets the width of the Shape outline.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.strokeThickness = value;
}

Shape.prototype.get_strokeThickness = function()
{
    /// <summary>Gets or sets the width of the Shape outline.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.strokeThickness);
}

Shape.prototype.set_strokeStartLineCap = function(value)
{
    /// <summary>Gets or sets a PenLineCap enumeration value that describes the Shape at the start of a Stroke.</summary>
    /// <param name="value" type="PenLineCap" integer="False" />
    TypeSafety({"PenLineCap" : value});   
    this.element.strokeStartLineCap = value.element;
}

Shape.prototype.get_strokeStartLineCap = function()
{
    /// <summary>Gets or sets a PenLineCap enumeration value that describes the Shape at the start of a Stroke.</summary>
    /// <returns type="PenLineCap" integer="False" />   
    return Convert.ToPenLineCap(this.element.strokeStartLineCap);
}

Shape.prototype.set_strokeEndLineCap = function(value)
{
    /// <summary>Gets or sets a PenLineCap enumeration value that describes the Shape at the end of a line.</summary>
    /// <param name="value" type="PenLineCap" integer="False" />
    TypeSafety({"PenLineCap" : value});   
    this.element.strokeEndLineCap = value.element;
}

Shape.prototype.get_strokeEndLineCap = function()
{
    /// <summary>Gets or sets a PenLineCap enumeration value that describes the Shape at the end of a line.</summary>
    /// <returns type="PenLineCap" integer="False" />   
    return Convert.ToPenLineCap(this.element.strokeEndLineCap);
}

Shape.prototype.set_strokeLineJoin = function(value)
{
    /// <summary>Gets or sets a PenLineJoin enumeration value that specifies the type of join used at the vertices of a Shape.</summary>
    /// <param name="value" type="PenLineJoin" integer="False" />
    TypeSafety({"PenLineJoin" : value});   
    this.element.strokeLineJoin = value.element;
}

Shape.prototype.get_strokeLineJoin = function()
{
    /// <summary>Gets or sets a PenLineJoin enumeration value that specifies the type of join used at the vertices of a Shape.</summary>
    /// <returns type="PenLineJoin" integer="False" />   
    return Convert.ToPenLineJoin(this.element.strokeLineJoin);
}

Shape.prototype.set_strokeDashOffset = function(value)
{
    /// <summary>Gets or sets a value that specifies the distance within the dash pattern where a dash begins.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.strokeDashOffset = value;
}

Shape.prototype.get_strokeDashOffset = function()
{
    /// <summary>Gets or sets a value that specifies the distance within the dash pattern where a dash begins.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.strokeDashOffset);
}

Shape.prototype.set_strokeDashCap = function(value)
{
    /// <summary>Gets or sets a PenLineCap enumeration value that specifies how the ends of a dash are drawn.</summary>
    /// <param name="value" type="PenLineCap" integer="False" />
    TypeSafety({"PenLineCap" : value});   
    this.element.strokeDashCap = value.element;
}

Shape.prototype.get_strokeDashCap = function()
{
    /// <summary>Gets or sets a PenLineCap enumeration value that specifies how the ends of a dash are drawn.</summary>
    /// <returns type="PenLineCap" integer="False" />   
    return Convert.ToPenLineCap(this.element.strokeDashCap);
}

Shape.prototype.set_strokeDashArray = function(value)
{
    /// <summary>Gets or sets a collection of Double values that indicate the pattern of dashes and gaps that is used to outline shapes.</summary>
    /// <param name="value" type="Double[]" integer="False" />
    TypeSafety({"Double[]" : value});   
    this.element.strokeDashArray = value;
}

Shape.prototype.set_stretch = function(value)
{
    /// <summary>Gets or sets a value that specifies how the content of this brush stretches.</summary>
    /// <param name="value" type="Stretch" integer="False" />
    TypeSafety({"Stretch" : value});   
    this.element.stretch = value.element;
}

Shape.prototype.get_stretch = function()
{
    /// <summary>Gets or sets a value that specifies how the content of this brush stretches.</summary>
    /// <returns type="Stretch" integer="False" />   
    return Convert.ToStretch(this.element.stretch);
}

Path = function(PathXamlElement) 
{
        /// <summary>Draws a series of connected lines and curves.</summary>
        /// <param name="PathXamlElement">Non strongly typed Xaml Element</param>
        this.element = PathXamlElement;
}
Path.createFromXaml = function(Host)
{
    /// <returns type="Path" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Path(Host.content.createFromXaml("<Path />"));
    } catch (ex) {}
    if (Host.getHost)
        return Path.CreateNew(Host.getHost());
    return;
}
Path.get_DataProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Path.Data");
}

Path.prototype = new Shape;

Path.prototype.set_data = function(value)
{
    /// <summary>Gets or sets a Geometry that specifies the shape to be drawn.</summary>
    /// <param name="value" type="Geometry" integer="False" />
    TypeSafety({"Geometry" : value});   
    this.element.data = value.element;
}

Path.prototype.get_data = function()
{
    /// <summary>Gets or sets a Geometry that specifies the shape to be drawn.</summary>
    /// <returns type="Geometry" integer="False" />   
    return Convert.ToGeometry(this.element.data);
}

Ellipse = function(EllipseXamlElement) 
{
        /// <summary>Draws an ellipse.</summary>
        /// <param name="EllipseXamlElement">Non strongly typed Xaml Element</param>
        this.element = EllipseXamlElement;
}
Ellipse.createFromXaml = function(Host)
{
    /// <returns type="Ellipse" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Ellipse(Host.content.createFromXaml("<Ellipse />"));
    } catch (ex) {}
    if (Host.getHost)
        return Ellipse.CreateNew(Host.getHost());
    return;
}
Ellipse.prototype = new Shape;

Line = function(LineXamlElement) 
{
        /// <summary>Draws a stright line between two points.</summary>
        /// <param name="LineXamlElement">Non strongly typed Xaml Element</param>
        this.element = LineXamlElement;
}
Line.createFromXaml = function(Host)
{
    /// <returns type="Line" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Line(Host.content.createFromXaml("<Line />"));
    } catch (ex) {}
    if (Host.getHost)
        return Line.CreateNew(Host.getHost());
    return;
}
Line.get_X1Property = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Line.X1");
}

Line.get_Y1Property = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Line.Y1");
}

Line.get_X2Property = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Line.X2");
}

Line.get_Y2Property = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Line.Y2");
}

Line.prototype = new Shape;

Line.prototype.set_x1 = function(value)
{
    /// <summary>Gets or sets the x-coordinate of the Line start point.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.x1 = value;
}

Line.prototype.get_x1 = function()
{
    /// <summary>Gets or sets the x-coordinate of the Line start point.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.x1);
}

Line.prototype.set_y1 = function(value)
{
    /// <summary>Gets or sets the y-coordinate of the Line start point.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.y1 = value;
}

Line.prototype.get_y1 = function()
{
    /// <summary>Gets or sets the y-coordinate of the Line start point.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.y1);
}

Line.prototype.set_x2 = function(value)
{
    /// <summary>Gets or sets the x-coordinate of the Line end point.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.x2 = value;
}

Line.prototype.get_x2 = function()
{
    /// <summary>Gets or sets the x-coordinate of the Line end point.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.x2);
}

Line.prototype.set_y2 = function(value)
{
    /// <summary>Gets or sets the y-coordinate of the Line end point.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.y2 = value;
}

Line.prototype.get_y2 = function()
{
    /// <summary>Gets or sets the y-coordinate of the Line end point.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.y2);
}

Polygon = function(PolygonXamlElement) 
{
        /// <summary>Draws a polygon, which is a connected series of lines that form a closed shape.</summary>
        /// <param name="PolygonXamlElement">Non strongly typed Xaml Element</param>
        this.element = PolygonXamlElement;
}
Polygon.createFromXaml = function(Host)
{
    /// <returns type="Polygon" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Polygon(Host.content.createFromXaml("<Polygon />"));
    } catch (ex) {}
    if (Host.getHost)
        return Polygon.CreateNew(Host.getHost());
    return;
}
Polygon.get_FillRuleProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Polygon.FillRule");
}

Polygon.get_PointsProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Polygon.Points");
}

Polygon.prototype = new Shape;

Polygon.prototype.set_fillRule = function(value)
{
    /// <summary>Gets or sets a value that determines how the intersecting areas (PathFigures) contained in this PathGeometry are combined.</summary>
    /// <param name="value" type="FillRule" integer="False" />
    TypeSafety({"FillRule" : value});   
    this.element.fillRule = value.element;
}

Polygon.prototype.get_fillRule = function()
{
    /// <summary>Gets or sets a value that determines how the intersecting areas (PathFigures) contained in this PathGeometry are combined.</summary>
    /// <returns type="FillRule" integer="False" />   
    return Convert.ToFillRule(this.element.fillRule);
}

Polygon.prototype.set_points = function(value)
{
    /// <summary>Gets or sets the PointCollection that define this PolyBezierSegment object.</summary>
    /// <param name="value" type="Point[]" integer="False" />
    TypeSafety({"Point[]" : value});   
    this.element.points = value;
}

Polyline = function(PolylineXamlElement) 
{
        /// <summary>Draws a series of connected straight lines.</summary>
        /// <param name="PolylineXamlElement">Non strongly typed Xaml Element</param>
        this.element = PolylineXamlElement;
}
Polyline.createFromXaml = function(Host)
{
    /// <returns type="Polyline" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Polyline(Host.content.createFromXaml("<Polyline />"));
    } catch (ex) {}
    if (Host.getHost)
        return Polyline.CreateNew(Host.getHost());
    return;
}
Polyline.get_FillRuleProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Polyline.FillRule");
}

Polyline.get_PointsProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Polyline.Points");
}

Polyline.prototype = new Shape;

Polyline.prototype.set_fillRule = function(value)
{
    /// <summary>Gets or sets a value that determines how the intersecting areas (PathFigures) contained in this PathGeometry are combined.</summary>
    /// <param name="value" type="FillRule" integer="False" />
    TypeSafety({"FillRule" : value});   
    this.element.fillRule = value.element;
}

Polyline.prototype.get_fillRule = function()
{
    /// <summary>Gets or sets a value that determines how the intersecting areas (PathFigures) contained in this PathGeometry are combined.</summary>
    /// <returns type="FillRule" integer="False" />   
    return Convert.ToFillRule(this.element.fillRule);
}

Polyline.prototype.set_points = function(value)
{
    /// <summary>Gets or sets the PointCollection that define this PolyBezierSegment object.</summary>
    /// <param name="value" type="Point[]" integer="False" />
    TypeSafety({"Point[]" : value});   
    this.element.points = value;
}

Rectangle = function(RectangleXamlElement) 
{
        /// <summary>Draws a rectangle.</summary>
        /// <param name="RectangleXamlElement">Non strongly typed Xaml Element</param>
        this.element = RectangleXamlElement;
}
Rectangle.createFromXaml = function(Host)
{
    /// <returns type="Rectangle" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Rectangle(Host.content.createFromXaml("<Rectangle />"));
    } catch (ex) {}
    if (Host.getHost)
        return Rectangle.CreateNew(Host.getHost());
    return;
}
Rectangle.get_RadiusXProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Rectangle.RadiusX");
}

Rectangle.get_RadiusYProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Rectangle.RadiusY");
}

Rectangle.prototype = new Shape;

Rectangle.prototype.set_radiusX = function(value)
{
    /// <summary>Gets or sets the x-radius value of the EllipseGeometry.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.radiusX = value;
}

Rectangle.prototype.get_radiusX = function()
{
    /// <summary>Gets or sets the x-radius value of the EllipseGeometry.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.radiusX);
}

Rectangle.prototype.set_radiusY = function(value)
{
    /// <summary>Gets or sets the y-radius value of the EllipseGeometry.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.radiusY = value;
}

Rectangle.prototype.get_radiusY = function()
{
    /// <summary>Gets or sets the y-radius value of the EllipseGeometry.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.radiusY);
}

Inline = function(InlineXamlElement) 
{
        /// <summary></summary>
        /// <param name="InlineXamlElement">Non strongly typed Xaml Element</param>
        this.element = InlineXamlElement;
}
Inline.createFromXaml = function(Host)
{
    /// <returns type="Inline" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Inline(Host.content.createFromXaml("<Inline />"));
    } catch (ex) {}
    if (Host.getHost)
        return Inline.CreateNew(Host.getHost());
    return;
}
Inline.get_FontSizeProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Inline.FontSize");
}

Inline.get_FontFamilyProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Inline.FontFamily");
}

Inline.get_FontWeightProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Inline.FontWeight");
}

Inline.get_FontStyleProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Inline.FontStyle");
}

Inline.get_FontStretchProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Inline.FontStretch");
}

Inline.get_TextDecorationsProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Inline.TextDecorations");
}

Inline.get_ForegroundProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Inline.Foreground");
}

Inline.prototype = new DependencyObject;

Inline.prototype.set_fontSize = function(value)
{
    /// <summary>Gets or sets the font size for the content in this element.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.fontSize = value;
}

Inline.prototype.get_fontSize = function()
{
    /// <summary>Gets or sets the font size for the content in this element.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.fontSize);
}

Inline.prototype.set_fontFamily = function(value)
{
    /// <summary>Gets or sets the preferred top-level font family for the content in this element.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.fontFamily = value;
}

Inline.prototype.get_fontFamily = function()
{
    /// <summary>Gets or sets the preferred top-level font family for the content in this element.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.fontFamily);
}

Inline.prototype.set_fontWeight = function(value)
{
    /// <summary>Gets or sets the top-level font weight for the content in this element.</summary>
    /// <param name="value" type="FontWeights" integer="False" />
    TypeSafety({"FontWeights" : value});   
    this.element.fontWeight = value.element;
}

Inline.prototype.get_fontWeight = function()
{
    /// <summary>Gets or sets the top-level font weight for the content in this element.</summary>
    /// <returns type="FontWeights" integer="False" />   
    return Convert.ToFontWeights(this.element.fontWeight);
}

Inline.prototype.set_fontStyle = function(value)
{
    /// <summary>Gets or sets the font style for the content in this element.</summary>
    /// <param name="value" type="FontStyles" integer="False" />
    TypeSafety({"FontStyles" : value});   
    this.element.fontStyle = value.element;
}

Inline.prototype.get_fontStyle = function()
{
    /// <summary>Gets or sets the font style for the content in this element.</summary>
    /// <returns type="FontStyles" integer="False" />   
    return Convert.ToFontStyles(this.element.fontStyle);
}

Inline.prototype.set_fontStretch = function(value)
{
    /// <summary>Gets or sets the font stretch for the content in this element.</summary>
    /// <param name="value" type="FontStretches" integer="False" />
    TypeSafety({"FontStretches" : value});   
    this.element.fontStretch = value.element;
}

Inline.prototype.get_fontStretch = function()
{
    /// <summary>Gets or sets the font stretch for the content in this element.</summary>
    /// <returns type="FontStretches" integer="False" />   
    return Convert.ToFontStretches(this.element.fontStretch);
}

Inline.prototype.set_textDecorations = function(value)
{
    /// <summary>Gets or sets the text decoration for the content in this element.</summary>
    /// <param name="value" type="TextDecorations" integer="False" />
    TypeSafety({"TextDecorations" : value});   
    this.element.textDecorations = value.element;
}

Inline.prototype.get_textDecorations = function()
{
    /// <summary>Gets or sets the text decoration for the content in this element.</summary>
    /// <returns type="TextDecorations" integer="False" />   
    return Convert.ToTextDecorations(this.element.textDecorations);
}

Inline.prototype.set_foreground = function(value)
{
    /// <summary>Gets or sets the Brush to apply to the content in this element.</summary>
    /// <param name="value" type="Brush" integer="False" />
    TypeSafety({"Brush" : value});   
    this.element.foreground = value.element;
}

Inline.prototype.get_foreground = function()
{
    /// <summary>Gets or sets the Brush to apply to the content in this element.</summary>
    /// <returns type="Brush" integer="False" />   
    return Convert.ToBrush(this.element.foreground);
}

Glyphs = function(GlyphsXamlElement) 
{
        /// <summary>Represents the set of glyphs that are used for rendering fixed text.</summary>
        /// <param name="GlyphsXamlElement">Non strongly typed Xaml Element</param>
        this.element = GlyphsXamlElement;
}
Glyphs.createFromXaml = function(Host)
{
    /// <returns type="Glyphs" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Glyphs(Host.content.createFromXaml("<Glyphs />"));
    } catch (ex) {}
    if (Host.getHost)
        return Glyphs.CreateNew(Host.getHost());
    return;
}
Glyphs.get_UnicodeStringProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Glyphs.UnicodeString");
}

Glyphs.get_IndicesProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Glyphs.Indices");
}

Glyphs.get_FontUriProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Glyphs.FontUri");
}

Glyphs.get_StyleSimulationsProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Glyphs.StyleSimulations");
}

Glyphs.get_FontRenderingEmSizeProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Glyphs.FontRenderingEmSize");
}

Glyphs.get_OriginXProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Glyphs.OriginX");
}

Glyphs.get_OriginYProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Glyphs.OriginY");
}

Glyphs.get_FillProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Glyphs.Fill");
}

Glyphs.prototype = new FrameworkElement;

Glyphs.prototype.set_unicodeString = function(value)
{
    /// <summary>Gets or sets the String that represents the Unicode string for the Glyphs object.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.unicodeString = value;
}

Glyphs.prototype.get_unicodeString = function()
{
    /// <summary>Gets or sets the String that represents the Unicode string for the Glyphs object.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.unicodeString);
}

Glyphs.prototype.set_indices = function(value)
{
    /// <summary>Gets or sets the glyph indices that represent the Glyphs object.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.indices = value;
}

Glyphs.prototype.get_indices = function()
{
    /// <summary>Gets or sets the glyph indices that represent the Glyphs object.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.indices);
}

Glyphs.prototype.set_fontUri = function(value)
{
    /// <summary>Gets or sets the Uri that represents the location of the font used for rendering the Glyphs.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.fontUri = value;
}

Glyphs.prototype.get_fontUri = function()
{
    /// <summary>Gets or sets the Uri that represents the location of the font used for rendering the Glyphs.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.fontUri);
}

Glyphs.prototype.set_styleSimulations = function(value)
{
    /// <summary>Gets or sets the StyleSimulations for the Glyphs object.</summary>
    /// <param name="value" type="StyleSimulations" integer="False" />
    TypeSafety({"StyleSimulations" : value});   
    this.element.styleSimulations = value.element;
}

Glyphs.prototype.get_styleSimulations = function()
{
    /// <summary>Gets or sets the StyleSimulations for the Glyphs object.</summary>
    /// <returns type="StyleSimulations" integer="False" />   
    return Convert.ToStyleSimulations(this.element.styleSimulations);
}

Glyphs.prototype.set_fontRenderingEmSize = function(value)
{
    /// <summary>Gets or sets the em size used for rendering the Glyphs.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.fontRenderingEmSize = value;
}

Glyphs.prototype.get_fontRenderingEmSize = function()
{
    /// <summary>Gets or sets the em size used for rendering the Glyphs.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.fontRenderingEmSize);
}

Glyphs.prototype.set_originX = function(value)
{
    /// <summary>Gets or sets the value of the x origin for the Glyphs object.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.originX = value;
}

Glyphs.prototype.get_originX = function()
{
    /// <summary>Gets or sets the value of the x origin for the Glyphs object.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.originX);
}

Glyphs.prototype.set_originY = function(value)
{
    /// <summary>Gets or sets the value of the x origin for the Glyphs object.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.originY = value;
}

Glyphs.prototype.get_originY = function()
{
    /// <summary>Gets or sets the value of the x origin for the Glyphs object.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.originY);
}

Glyphs.prototype.set_fill = function(value)
{
    /// <summary>Gets the sets the Brush that is used for the fill of the Glyphs.</summary>
    /// <param name="value" type="Brush" integer="False" />
    TypeSafety({"Brush" : value});   
    this.element.fill = value.element;
}

Glyphs.prototype.get_fill = function()
{
    /// <summary>Gets the sets the Brush that is used for the fill of the Glyphs.</summary>
    /// <returns type="Brush" integer="False" />   
    return Convert.ToBrush(this.element.fill);
}

Run = function(RunXamlElement) 
{
        /// <summary>Represents a discrete section of formatted or unformatted text.</summary>
        /// <param name="RunXamlElement">Non strongly typed Xaml Element</param>
        this.element = RunXamlElement;
}
Run.createFromXaml = function(Host)
{
    /// <returns type="Run" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Run(Host.content.createFromXaml("<Run />"));
    } catch (ex) {}
    if (Host.getHost)
        return Run.CreateNew(Host.getHost());
    return;
}
Run.get_TextProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Run.Text");
}

Run.prototype = new Inline;

Run.prototype.set_text = function(value)
{
    /// <summary>Gets downloaded data from a successful download request.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.text = value;
}

Run.prototype.get_text = function()
{
    /// <summary>Gets downloaded data from a successful download request.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.text);
}

LineBreak = function(LineBreakXamlElement) 
{
        /// <summary>Represents an explicit new line in a TextBlock.</summary>
        /// <param name="LineBreakXamlElement">Non strongly typed Xaml Element</param>
        this.element = LineBreakXamlElement;
}
LineBreak.createFromXaml = function(Host)
{
    /// <returns type="LineBreak" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new LineBreak(Host.content.createFromXaml("<LineBreak />"));
    } catch (ex) {}
    if (Host.getHost)
        return LineBreak.CreateNew(Host.getHost());
    return;
}
LineBreak.prototype = new Inline;

Panel = function(PanelXamlElement) 
{
        /// <summary></summary>
        /// <param name="PanelXamlElement">Non strongly typed Xaml Element</param>
        this.element = PanelXamlElement;
}
Panel.createFromXaml = function(Host)
{
    /// <returns type="Panel" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Panel(Host.content.createFromXaml("<Panel />"));
    } catch (ex) {}
    if (Host.getHost)
        return Panel.CreateNew(Host.getHost());
    return;
}
Panel.get_ChildrenProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Panel.Children");
}

Panel.get_BackgroundProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Panel.Background");
}

Panel.prototype = new FrameworkElement;

Panel.prototype.set_children = function(value)
{
    /// <summary>Gets or sets the collection of child elements on the Canvas.</summary>
    /// <param name="value" type="VisualCollection" integer="False" />
    TypeSafety({"VisualCollection" : value});   
    this.element.children = value.element;
}

Panel.prototype.get_children = function()
{
    /// <summary>Gets or sets the collection of child elements on the Canvas.</summary>
    /// <returns type="VisualCollection" integer="False" />   
    return Convert.ToVisualCollection(this.element.children);
}

Panel.prototype.set_background = function(value)
{
    /// <summary>Gets or sets the background color of the rectangular region that display XAML content.</summary>
    /// <param name="value" type="Brush" integer="False" />
    TypeSafety({"Brush" : value});   
    this.element.background = value.element;
}

Panel.prototype.get_background = function()
{
    /// <summary>Gets or sets the background color of the rectangular region that display XAML content.</summary>
    /// <returns type="Brush" integer="False" />   
    return Convert.ToBrush(this.element.background);
}

MediaBase = function(MediaBaseXamlElement) 
{
        /// <summary></summary>
        /// <param name="MediaBaseXamlElement">Non strongly typed Xaml Element</param>
        this.element = MediaBaseXamlElement;
}
MediaBase.createFromXaml = function(Host)
{
    /// <returns type="MediaBase" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new MediaBase(Host.content.createFromXaml("<MediaBase />"));
    } catch (ex) {}
    if (Host.getHost)
        return MediaBase.CreateNew(Host.getHost());
    return;
}
MediaBase.get_SourceProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaBase.Source");
}

MediaBase.get_StretchProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaBase.Stretch");
}

MediaBase.prototype = new FrameworkElement;

MediaBase.prototype.set_source = function(value)
{
    /// <summary>Gets or sets the image displayed by this ImageBrush.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.source = value;
}

MediaBase.prototype.get_source = function()
{
    /// <summary>Gets or sets the image displayed by this ImageBrush.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.source);
}

MediaBase.prototype.set_stretch = function(value)
{
    /// <summary>Gets or sets a value that specifies how the content of this brush stretches.</summary>
    /// <param name="value" type="Stretch" integer="False" />
    TypeSafety({"Stretch" : value});   
    this.element.stretch = value.element;
}

MediaBase.prototype.get_stretch = function()
{
    /// <summary>Gets or sets a value that specifies how the content of this brush stretches.</summary>
    /// <returns type="Stretch" integer="False" />   
    return Convert.ToStretch(this.element.stretch);
}

ImageSL = function(ImageSLXamlElement) 
{
        /// <summary></summary>
        /// <param name="ImageSLXamlElement">Non strongly typed Xaml Element</param>
        this.element = ImageSLXamlElement;
}
ImageSL.createFromXaml = function(Host)
{
    /// <returns type="ImageSL" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new ImageSL(Host.content.createFromXaml("<ImageSL />"));
    } catch (ex) {}
    if (Host.getHost)
        return ImageSL.CreateNew(Host.getHost());
    return;
}
ImageSL.get_DownloadProgressProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("ImageSL.DownloadProgress");
}

ImageSL.prototype = new MediaBase;

ImageSL.prototype.set_downloadProgress = function(value)
{
    /// <summary>Gets a value that indicates the percentage of downloaded content.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.downloadProgress = value;
}

ImageSL.prototype.get_downloadProgress = function()
{
    /// <summary>Gets a value that indicates the percentage of downloaded content.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.downloadProgress);
}

ImageSL.prototype.setSource = function(Downloader, PartName)
{
     /// <summary>Sets the source value of an object with downloaded content.</summary>
    /// <param name="Downloader" type="DependencyObject" integer="False" >The object containing the downloaded content.</param>   
    /// <param name="PartName" type="String" integer="False" >The name of the specific part of the downloaded content package. When the downloaded content package is a Zip file, part refers to the contents of a filename within downloader. If the downloaded content does not represent packaged content, set part to an empty string.</param>   
    TypeSafety({"DependencyObject":Downloader, "String":PartName});
    return (this.element.setSource(Downloader.element, PartName));
}

ImageSL.prototype.add_ImageFailed = function(handler) {
    /// <summary>Occurs when there is a media related error.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("ImageFailed", handler);
}
    
ImageSL.prototype.remove_ImageFailed = function(eventId) {
    /// <summary>Occurs when there is a media related error.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_ImageSL</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("ImageFailed", eventId);
}

Canvas = function(CanvasXamlElement) 
{
        /// <summary>Defines an area within which you can explicitly position child elements by using coordinates relative to the Canvas area.</summary>
        /// <param name="CanvasXamlElement">Non strongly typed Xaml Element</param>
        this.element = CanvasXamlElement;
}
Canvas.createFromXaml = function(Host)
{
    /// <returns type="Canvas" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Canvas(Host.content.createFromXaml("<Canvas />"));
    } catch (ex) {}
    if (Host.getHost)
        return Canvas.CreateNew(Host.getHost());
    return;
}
Canvas.get_LeftProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Canvas.Left");
}

Canvas.get_TopProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("Canvas.Top");
}

Canvas.prototype = new Panel;

TextBlock = function(TextBlockXamlElement) 
{
        /// <summary>Represents a lightweight object for displaying single-line and multi-line multi-formatted text.</summary>
        /// <param name="TextBlockXamlElement">Non strongly typed Xaml Element</param>
        this.element = TextBlockXamlElement;
}
TextBlock.createFromXaml = function(Host)
{
    /// <returns type="TextBlock" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new TextBlock(Host.content.createFromXaml("<TextBlock />"));
    } catch (ex) {}
    if (Host.getHost)
        return TextBlock.CreateNew(Host.getHost());
    return;
}
TextBlock.get_FontSizeProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TextBlock.FontSize");
}

TextBlock.get_FontFamilyProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TextBlock.FontFamily");
}

TextBlock.get_FontWeightProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TextBlock.FontWeight");
}

TextBlock.get_FontStyleProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TextBlock.FontStyle");
}

TextBlock.get_FontStretchProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TextBlock.FontStretch");
}

TextBlock.get_TextDecorationsProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TextBlock.TextDecorations");
}

TextBlock.get_ForegroundProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TextBlock.Foreground");
}

TextBlock.get_TextWrappingProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TextBlock.TextWrapping");
}

TextBlock.get_TextProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TextBlock.Text");
}

TextBlock.get_ActualWidthProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TextBlock.ActualWidth");
}

TextBlock.get_ActualHeightProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TextBlock.ActualHeight");
}

TextBlock.get_InlinesProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("TextBlock.Inlines");
}

TextBlock.prototype = new FrameworkElement;

TextBlock.prototype.set_fontSize = function(value)
{
    /// <summary>Gets or sets the font size for the content in this element.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.fontSize = value;
}

TextBlock.prototype.get_fontSize = function()
{
    /// <summary>Gets or sets the font size for the content in this element.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.fontSize);
}

TextBlock.prototype.set_fontFamily = function(value)
{
    /// <summary>Gets or sets the preferred top-level font family for the content in this element.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.fontFamily = value;
}

TextBlock.prototype.get_fontFamily = function()
{
    /// <summary>Gets or sets the preferred top-level font family for the content in this element.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.fontFamily);
}

TextBlock.prototype.set_fontWeight = function(value)
{
    /// <summary>Gets or sets the top-level font weight for the content in this element.</summary>
    /// <param name="value" type="FontWeights" integer="False" />
    TypeSafety({"FontWeights" : value});   
    this.element.fontWeight = value.element;
}

TextBlock.prototype.get_fontWeight = function()
{
    /// <summary>Gets or sets the top-level font weight for the content in this element.</summary>
    /// <returns type="FontWeights" integer="False" />   
    return Convert.ToFontWeights(this.element.fontWeight);
}

TextBlock.prototype.set_fontStyle = function(value)
{
    /// <summary>Gets or sets the font style for the content in this element.</summary>
    /// <param name="value" type="FontStyles" integer="False" />
    TypeSafety({"FontStyles" : value});   
    this.element.fontStyle = value.element;
}

TextBlock.prototype.get_fontStyle = function()
{
    /// <summary>Gets or sets the font style for the content in this element.</summary>
    /// <returns type="FontStyles" integer="False" />   
    return Convert.ToFontStyles(this.element.fontStyle);
}

TextBlock.prototype.set_fontStretch = function(value)
{
    /// <summary>Gets or sets the font stretch for the content in this element.</summary>
    /// <param name="value" type="FontStretches" integer="False" />
    TypeSafety({"FontStretches" : value});   
    this.element.fontStretch = value.element;
}

TextBlock.prototype.get_fontStretch = function()
{
    /// <summary>Gets or sets the font stretch for the content in this element.</summary>
    /// <returns type="FontStretches" integer="False" />   
    return Convert.ToFontStretches(this.element.fontStretch);
}

TextBlock.prototype.set_textDecorations = function(value)
{
    /// <summary>Gets or sets the text decoration for the content in this element.</summary>
    /// <param name="value" type="TextDecorations" integer="False" />
    TypeSafety({"TextDecorations" : value});   
    this.element.textDecorations = value.element;
}

TextBlock.prototype.get_textDecorations = function()
{
    /// <summary>Gets or sets the text decoration for the content in this element.</summary>
    /// <returns type="TextDecorations" integer="False" />   
    return Convert.ToTextDecorations(this.element.textDecorations);
}

TextBlock.prototype.set_foreground = function(value)
{
    /// <summary>Gets or sets the Brush to apply to the content in this element.</summary>
    /// <param name="value" type="Brush" integer="False" />
    TypeSafety({"Brush" : value});   
    this.element.foreground = value.element;
}

TextBlock.prototype.get_foreground = function()
{
    /// <summary>Gets or sets the Brush to apply to the content in this element.</summary>
    /// <returns type="Brush" integer="False" />   
    return Convert.ToBrush(this.element.foreground);
}

TextBlock.prototype.set_textWrapping = function(value)
{
    /// <summary>Gets or sets a value that indicates how the TextBlock should wrap text.</summary>
    /// <param name="value" type="TextWrapping" integer="False" />
    TypeSafety({"TextWrapping" : value});   
    this.element.textWrapping = value.element;
}

TextBlock.prototype.get_textWrapping = function()
{
    /// <summary>Gets or sets a value that indicates how the TextBlock should wrap text.</summary>
    /// <returns type="TextWrapping" integer="False" />   
    return Convert.ToTextWrapping(this.element.textWrapping);
}

TextBlock.prototype.set_text = function(value)
{
    /// <summary>Gets downloaded data from a successful download request.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.text = value;
}

TextBlock.prototype.get_text = function()
{
    /// <summary>Gets downloaded data from a successful download request.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.text);
}

TextBlock.prototype.get_actualWidth = function()
{
    /// <summary>Gets the width of the rendering area of the Silverlight plugin.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.actualWidth);
}

TextBlock.prototype.get_actualHeight = function()
{
    /// <summary>Gets the height of the rendering area of the Silverlight plugin.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.actualHeight);
}

TextBlock.prototype.set_inlines = function(value)
{
    /// <summary>Gets the collection of inline text elements within a TextBlock.</summary>
    /// <param name="value" type="Inlines" integer="False" />
    TypeSafety({"Inlines" : value});   
    this.element.inlines = value.element;
}

TextBlock.prototype.get_inlines = function()
{
    /// <summary>Gets the collection of inline text elements within a TextBlock.</summary>
    /// <returns type="Inlines" integer="False" />   
    return Convert.ToInlines(this.element.inlines);
}

TextBlock.prototype.setFontSource = function(Downloader)
{
     /// <summary>Adds font files in the downloaded content to the object's collection of type faces.</summary>
    /// <param name="Downloader" type="DependencyObject" integer="False" >The object containing the downloaded content. Set downloader to null to restore the default font for the object.</param>   
    TypeSafety({"DependencyObject":Downloader});
    return (this.element.setFontSource(Downloader.element));
}

MediaElement = function(MediaElementXamlElement) 
{
        /// <summary>Represents an object that contains audio, video, or both.</summary>
        /// <param name="MediaElementXamlElement">Non strongly typed Xaml Element</param>
        this.element = MediaElementXamlElement;
}
MediaElement.createFromXaml = function(Host)
{
    /// <returns type="MediaElement" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new MediaElement(Host.content.createFromXaml("<MediaElement />"));
    } catch (ex) {}
    if (Host.getHost)
        return MediaElement.CreateNew(Host.getHost());
    return;
}
MediaElement.get_IsMutedProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.IsMuted");
}

MediaElement.get_AutoPlayProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.AutoPlay");
}

MediaElement.get_VolumeProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.Volume");
}

MediaElement.get_BalanceProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.Balance");
}

MediaElement.get_NaturalVideoHeightProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.NaturalVideoHeight");
}

MediaElement.get_NaturalVideoWidthProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.NaturalVideoWidth");
}

MediaElement.get_NaturalDurationProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.NaturalDuration");
}

MediaElement.get_PositionProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.Position");
}

MediaElement.get_DownloadProgressProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.DownloadProgress");
}

MediaElement.get_BufferingProgressProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.BufferingProgress");
}

MediaElement.get_CurrentStateProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.CurrentState");
}

MediaElement.get_BufferingTimeProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.BufferingTime");
}

MediaElement.get_MarkersProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.Markers");
}

MediaElement.get_CanSeekProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.CanSeek");
}

MediaElement.get_CanPauseProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.CanPause");
}

MediaElement.get_AttributesProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.Attributes");
}

MediaElement.get_AudioStreamCountProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.AudioStreamCount");
}

MediaElement.get_AudioStreamIndexProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("MediaElement.AudioStreamIndex");
}

MediaElement.prototype = new MediaBase;

MediaElement.prototype.set_isMuted = function(value)
{
    /// <summary>Gets or sets a value indicating whether the audio is muted.</summary>
    /// <param name="value" type="Boolean" integer="False" />
    TypeSafety({"Boolean" : value});   
    this.element.isMuted = value;
}

MediaElement.prototype.get_isMuted = function()
{
    /// <summary>Gets or sets a value indicating whether the audio is muted.</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.isMuted);
}

MediaElement.prototype.set_autoPlay = function(value)
{
    /// <summary>Gets or sets a value indicating if media will begin playback automatically when the Source property is set.</summary>
    /// <param name="value" type="Boolean" integer="False" />
    TypeSafety({"Boolean" : value});   
    this.element.autoPlay = value;
}

MediaElement.prototype.get_autoPlay = function()
{
    /// <summary>Gets or sets a value indicating if media will begin playback automatically when the Source property is set.</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.autoPlay);
}

MediaElement.prototype.set_volume = function(value)
{
    /// <summary>Gets or sets the media's volume.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.volume = value;
}

MediaElement.prototype.get_volume = function()
{
    /// <summary>Gets or sets the media's volume.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.volume);
}

MediaElement.prototype.set_balance = function(value)
{
    /// <summary>Gets or sets the ratio of volume across stereo speakers.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.balance = value;
}

MediaElement.prototype.get_balance = function()
{
    /// <summary>Gets or sets the ratio of volume across stereo speakers.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.balance);
}

MediaElement.prototype.set_naturalVideoHeight = function(value)
{
    /// <summary>Gets the height of the video associated with the media.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.naturalVideoHeight = value;
}

MediaElement.prototype.get_naturalVideoHeight = function()
{
    /// <summary>Gets the height of the video associated with the media.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.naturalVideoHeight);
}

MediaElement.prototype.set_naturalVideoWidth = function(value)
{
    /// <summary>Gets the width of the video associated with the media.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.naturalVideoWidth = value;
}

MediaElement.prototype.get_naturalVideoWidth = function()
{
    /// <summary>Gets the width of the video associated with the media.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.naturalVideoWidth);
}

MediaElement.prototype.set_naturalDuration = function(value)
{
    /// <summary>Gets the natural duration of the media.</summary>
    /// <param name="value" type="Duration" integer="False" />
    TypeSafety({"Duration" : value});   
    this.element.naturalDuration = value.element;
}

MediaElement.prototype.get_naturalDuration = function()
{
    /// <summary>Gets the natural duration of the media.</summary>
    /// <returns type="Duration" integer="False" />   
    return Convert.ToDuration(this.element.naturalDuration);
}

MediaElement.prototype.set_position = function(value)
{
    /// <summary>Gets or sets the current progress through the media's playback time.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.position = value;
}

MediaElement.prototype.get_position = function()
{
    /// <summary>Gets or sets the current progress through the media's playback time.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.position);
}

MediaElement.prototype.set_downloadProgress = function(value)
{
    /// <summary>Gets a value that indicates the percentage of downloaded content.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.downloadProgress = value;
}

MediaElement.prototype.get_downloadProgress = function()
{
    /// <summary>Gets a value that indicates the percentage of downloaded content.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.downloadProgress);
}

MediaElement.prototype.set_bufferingProgress = function(value)
{
    /// <summary>Gets a value that indicates the current percentage of buffering progress.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.bufferingProgress = value;
}

MediaElement.prototype.get_bufferingProgress = function()
{
    /// <summary>Gets a value that indicates the current percentage of buffering progress.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.bufferingProgress);
}

MediaElement.prototype.get_currentState = function()
{
    /// <summary>Gets the status of the MediaElement.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.currentState);
}

MediaElement.prototype.set_bufferingTime = function(value)
{
    /// <summary>Gets or sets amount of time to buffer.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.bufferingTime = value;
}

MediaElement.prototype.get_bufferingTime = function()
{
    /// <summary>Gets or sets amount of time to buffer.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.bufferingTime);
}

MediaElement.prototype.set_markers = function(value)
{
    /// <summary>Gets the collection of timeline markers associated with the currently loaded media file.</summary>
    /// <param name="value" type="TimelineMarkerCollection" integer="False" />
    TypeSafety({"TimelineMarkerCollection" : value});   
    this.element.markers = value.element;
}

MediaElement.prototype.get_markers = function()
{
    /// <summary>Gets the collection of timeline markers associated with the currently loaded media file.</summary>
    /// <returns type="TimelineMarkerCollection" integer="False" />   
    return Convert.ToTimelineMarkerCollection(this.element.markers);
}

MediaElement.prototype.get_canSeek = function()
{
    /// <summary></summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.canSeek);
}

MediaElement.prototype.get_canPause = function()
{
    /// <summary>Gets a value indicating if media can be paused if the Pause method is called.</summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.canPause);
}

MediaElement.prototype.set_attributes = function(value)
{
    /// <summary>Gets the collection of MediaAttribute objects which corresponds to the current entry in the ASX file that Source is set to.</summary>
    /// <param name="value" type="MediaAttributeCollection" integer="False" />
    TypeSafety({"MediaAttributeCollection" : value});   
    this.element.attributes = value.element;
}

MediaElement.prototype.get_attributes = function()
{
    /// <summary>Gets the collection of MediaAttribute objects which corresponds to the current entry in the ASX file that Source is set to.</summary>
    /// <returns type="MediaAttributeCollection" integer="False" />   
    return Convert.ToMediaAttributeCollection(this.element.attributes);
}

MediaElement.prototype.set_audioStreamCount = function(value)
{
    /// <summary>Gets the number of audio streams available in the current media file.</summary>
    /// <param name="value" type="Number" integer="True" />
    TypeSafety({"Number" : value});   
    this.element.audioStreamCount = value;
}

MediaElement.prototype.get_audioStreamCount = function()
{
    /// <summary>Gets the number of audio streams available in the current media file.</summary>
    /// <returns type="Number" integer="True" />   
    return (this.element.audioStreamCount);
}

MediaElement.prototype.set_audioStreamIndex = function(value)
{
    /// <summary>Gets or sets a value indicating if media will begin playback automatically when the Source property is set.</summary>
    /// <param name="value" type="Number" integer="True" />
    TypeSafety({"Number" : value});   
    this.element.audioStreamIndex = value;
}

MediaElement.prototype.get_audioStreamIndex = function()
{
    /// <summary>Gets or sets a value indicating if media will begin playback automatically when the Source property is set.</summary>
    /// <returns type="Number" integer="True" />   
    return (this.element.audioStreamIndex);
}

MediaElement.prototype.stop = function()
{
     /// <summary>Stops and resets media to be played from the beginning.</summary>
    TypeSafety({});
    return (this.element.stop());
}

MediaElement.prototype.play = function()
{
     /// <summary>Plays media from the current position.</summary>
    TypeSafety({});
    return (this.element.play());
}

MediaElement.prototype.pause = function()
{
     /// <summary>Pauses media at the current position.</summary>
    TypeSafety({});
    return (this.element.pause());
}

MediaElement.prototype.setSource = function(Downloader, PartName)
{
     /// <summary>Sets the source value of an object with downloaded content.</summary>
    /// <param name="Downloader" type="DependencyObject" integer="False" >The object containing the downloaded content.</param>   
    /// <param name="PartName" type="String" integer="False" >The name of the specific part of the downloaded content package. When the downloaded content package is a Zip file, part refers to the contents of a filename within downloader. If the downloaded content does not represent packaged content, set part to an empty string.</param>   
    TypeSafety({"DependencyObject":Downloader, "String":PartName});
    return (this.element.setSource(Downloader.element, PartName));
}

MediaElement.prototype.add_MediaOpened = function(handler) {
    /// <summary>Occurs when the media stream has been validated, opened, and the file headers have been read.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("MediaOpened", handler);
}
    
MediaElement.prototype.remove_MediaOpened = function(eventId) {
    /// <summary>Occurs when the media stream has been validated, opened, and the file headers have been read.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_MediaElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("MediaOpened", eventId);
}

MediaElement.prototype.add_MediaEnded = function(handler) {
    /// <summary>Occurs when the MediaElement is no longer playing audio or video.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("MediaEnded", handler);
}
    
MediaElement.prototype.remove_MediaEnded = function(eventId) {
    /// <summary>Occurs when the MediaElement is no longer playing audio or video.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_MediaElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("MediaEnded", eventId);
}

MediaElement.prototype.add_MediaFailed = function(handler) {
    /// <summary>Occurs when there is a media related error.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("MediaFailed", handler);
}
    
MediaElement.prototype.remove_MediaFailed = function(eventId) {
    /// <summary>Occurs when there is a media related error.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_MediaElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("MediaFailed", eventId);
}

MediaElement.prototype.add_DownloadProgressChanged = function(handler) {
    /// <summary>Occurs while content is being downloaded during a download request.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("DownloadProgressChanged", handler);
}
    
MediaElement.prototype.remove_DownloadProgressChanged = function(eventId) {
    /// <summary>Occurs while content is being downloaded during a download request.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_MediaElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("DownloadProgressChanged", eventId);
}

MediaElement.prototype.add_BufferingProgressChanged = function(handler) {
    /// <summary>Occurs when the BufferingProgress property changes.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("BufferingProgressChanged", handler);
}
    
MediaElement.prototype.remove_BufferingProgressChanged = function(eventId) {
    /// <summary>Occurs when the BufferingProgress property changes.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_MediaElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("BufferingProgressChanged", eventId);
}

MediaElement.prototype.add_CurrentStateChanged = function(handler) {
    /// <summary>Occurs when the value of the CurrentState property changes.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("CurrentStateChanged", handler);
}
    
MediaElement.prototype.remove_CurrentStateChanged = function(eventId) {
    /// <summary>Occurs when the value of the CurrentState property changes.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_MediaElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("CurrentStateChanged", eventId);
}

MediaElement.prototype.add_MarkerReached = function(handler) {
    /// <summary>Occurs when a timeline marker is encountered during media playback.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("MarkerReached", handler);
}
    
MediaElement.prototype.remove_MarkerReached = function(eventId) {
    /// <summary>Occurs when a timeline marker is encountered during media playback.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_MediaElement</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("MarkerReached", eventId);
}

InkPresenter = function(InkPresenterXamlElement) 
{
        /// <summary>Element that displays ink and can be a child, sibling or parent of other elements.</summary>
        /// <param name="InkPresenterXamlElement">Non strongly typed Xaml Element</param>
        this.element = InkPresenterXamlElement;
}
InkPresenter.createFromXaml = function(Host)
{
    /// <returns type="InkPresenter" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new InkPresenter(Host.content.createFromXaml("<InkPresenter />"));
    } catch (ex) {}
    if (Host.getHost)
        return InkPresenter.CreateNew(Host.getHost());
    return;
}
InkPresenter.get_StrokesProperty = function()
{
    /// <returns type="DependencyProperty" />
    return Convert.ToDependencyProperty("InkPresenter.Strokes");
}

InkPresenter.prototype = new Canvas;

InkPresenter.prototype.set_strokes = function(value)
{
    /// <summary>The collection of ink strokes that correspond to the InkPresenter.</summary>
    /// <param name="value" type="StrokeCollection" integer="False" />
    TypeSafety({"StrokeCollection" : value});   
    this.element.strokes = value.element;
}

InkPresenter.prototype.get_strokes = function()
{
    /// <summary>The collection of ink strokes that correspond to the InkPresenter.</summary>
    /// <returns type="StrokeCollection" integer="False" />   
    return Convert.ToStrokeCollection(this.element.strokes);
}

Control = function(ControlXamlElement) 
{
        /// <summary></summary>
        /// <param name="ControlXamlElement">Non strongly typed Xaml Element</param>
        this.element = ControlXamlElement;
}
Control.createFromXaml = function(Host)
{
    /// <returns type="Control" />
    if (!Host)
        return;
    try { 
    if (Host.content)
        return new Control(Host.content.createFromXaml("<Control />"));
    } catch (ex) {}
    if (Host.getHost)
        return Control.CreateNew(Host.getHost());
    return;
}
Control.prototype = new FrameworkElement;

Duration = function(DurationXamlElement) 
{
        /// <summary>Represents the duration of time that a Timeline is active.</summary>
        /// <param name="DurationXamlElement">Non strongly typed Xaml Element</param>
        this.element = DurationXamlElement;
}
Duration.prototype.get_hasTimeSpan = function()
{
    /// <summary></summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.hasTimeSpan);
}

Duration.prototype.get_automatic = function()
{
    /// <summary></summary>
    /// <returns type="Duration" integer="False" />   
    return Convert.ToDuration(this.element.automatic);
}

Duration.prototype.get_forever = function()
{
    /// <summary></summary>
    /// <returns type="Duration" integer="False" />   
    return Convert.ToDuration(this.element.forever);
}

Duration.prototype.get_timeSpan = function()
{
    /// <summary></summary>
    /// <returns type="String" integer="False" />   
    return (this.element.timeSpan);
}

Duration.prototype.compare = function(t1, t2)
{
     /// <summary></summary>
    /// <param name="t1" type="Duration" integer="False" ></param>   
    /// <param name="t2" type="Duration" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Duration":t1, "Duration":t2});
    return (this.element.compare(t1.element, t2.element));
}

Duration.prototype.plus = function(duration)
{
     /// <summary></summary>
    /// <param name="duration" type="Duration" integer="False" ></param>   
    /// <returns type="Duration" integer="False" />   
    TypeSafety({"Duration":duration});
    return Convert.ToDuration(this.element.plus(duration.element));
}

Duration.prototype.add = function(duration)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="duration" type="Duration" integer="False" >The object to add to the collection.</param>   
    /// <returns type="Duration" integer="False" />   
    TypeSafety({"Duration":duration});
    return Convert.ToDuration(this.element.add(duration.element));
}

Duration.prototype.equals = function(value)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="value" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":value});
    return (this.element.equals(value));
}

Duration.prototype.equals = function(duration)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="duration" type="Duration" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Duration":duration});
    return (this.element.equals(duration.element));
}

Duration.prototype.equals = function(t1, t2)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="t1" type="Duration" integer="False" >The object to compare to the calling object.</param>   
    /// <param name="t2" type="Duration" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Duration":t1, "Duration":t2});
    return (this.element.equals(t1.element, t2.element));
}

Duration.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

Duration.prototype.subtract = function(duration)
{
     /// <summary></summary>
    /// <param name="duration" type="Duration" integer="False" ></param>   
    /// <returns type="Duration" integer="False" />   
    TypeSafety({"Duration":duration});
    return Convert.ToDuration(this.element.subtract(duration.element));
}

Duration.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

Duration.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

Duration.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

XamlParseException = function(XamlParseExceptionXamlElement) 
{
        /// <summary></summary>
        /// <param name="XamlParseExceptionXamlElement">Non strongly typed Xaml Element</param>
        this.element = XamlParseExceptionXamlElement;
}
XamlParseException.prototype.get_lineNumber = function()
{
    /// <summary>Gets the line number at which the parser error occurred.</summary>
    /// <returns type="UInt32" integer="False" />   
    return (this.element.lineNumber);
}

XamlParseException.prototype.get_linePosition = function()
{
    /// <summary></summary>
    /// <returns type="UInt32" integer="False" />   
    return (this.element.linePosition);
}

XamlParseException.prototype.get_message = function()
{
    /// <summary>Gets the error description associated with the error.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.message);
}

XamlParseException.prototype.get_data = function()
{
    /// <summary>Gets or sets a Geometry that specifies the shape to be drawn.</summary>
    /// <returns type="IDictionary" integer="False" />   
    return (this.element.data);
}

XamlParseException.prototype.get_innerException = function()
{
    /// <summary></summary>
    /// <returns type="Exception" integer="False" />   
    return (this.element.innerException);
}

XamlParseException.prototype.get_targetSite = function()
{
    /// <summary></summary>
    /// <returns type="MethodBase" integer="False" />   
    return (this.element.targetSite);
}

XamlParseException.prototype.get_stackTrace = function()
{
    /// <summary></summary>
    /// <returns type="String" integer="False" />   
    return (this.element.stackTrace);
}

XamlParseException.prototype.set_helpLink = function(value)
{
    /// <summary></summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.helpLink = value;
}

XamlParseException.prototype.get_helpLink = function()
{
    /// <summary></summary>
    /// <returns type="String" integer="False" />   
    return (this.element.helpLink);
}

XamlParseException.prototype.set_source = function(value)
{
    /// <summary>Gets or sets the image displayed by this ImageBrush.</summary>
    /// <param name="value" type="String" integer="False" />
    TypeSafety({"String" : value});   
    this.element.source = value;
}

XamlParseException.prototype.get_source = function()
{
    /// <summary>Gets or sets the image displayed by this ImageBrush.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.source);
}

XamlParseException.prototype.getBaseException = function()
{
     /// <summary></summary>
    /// <returns type="Exception" integer="False" />   
    TypeSafety({});
    return (this.element.getBaseException());
}

XamlParseException.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

XamlParseException.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

XamlParseException.prototype.getObjectData = function(info, context)
{
     /// <summary></summary>
    /// <param name="info" type="SerializationInfo" integer="False" ></param>   
    /// <param name="context" type="StreamingContext" integer="False" ></param>   
    TypeSafety({"SerializationInfo":info, "StreamingContext":context});
    return (this.element.getObjectData(info, context));
}

XamlParseException.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

XamlParseException.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

XamlParseException.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

XamlParseException.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

BrowserHost = function(BrowserHostXamlElement) 
{
        /// <summary></summary>
        /// <param name="BrowserHostXamlElement">Non strongly typed Xaml Element</param>
        this.element = BrowserHostXamlElement;
}
BrowserHost.prototype.get_actualWidth = function()
{
    /// <summary>Gets the width of the rendering area of the Silverlight plugin.</summary>
    /// <returns type="UInt32" integer="False" />   
    return (this.element.actualWidth);
}

BrowserHost.prototype.get_actualHeight = function()
{
    /// <summary>Gets the height of the rendering area of the Silverlight plugin.</summary>
    /// <returns type="UInt32" integer="False" />   
    return (this.element.actualHeight);
}

BrowserHost.prototype.set_isFullScreen = function(value)
{
    /// <summary></summary>
    /// <param name="value" type="Boolean" integer="False" />
    TypeSafety({"Boolean" : value});   
    this.element.isFullScreen = value;
}

BrowserHost.prototype.get_isFullScreen = function()
{
    /// <summary></summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.isFullScreen);
}

BrowserHost.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

BrowserHost.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

BrowserHost.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

BrowserHost.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

BrowserHost.prototype.add_FullScreenChange = function(handler) {
    /// <summary>Occurs whenever the FullScreen property of the Silverlight plugin changes.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("FullScreenChange", handler);
}
    
BrowserHost.prototype.remove_FullScreenChange = function(eventId) {
    /// <summary>Occurs whenever the FullScreen property of the Silverlight plugin changes.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_BrowserHost</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("FullScreenChange", eventId);
}

BrowserHost.prototype.add_Resize = function(handler) {
    /// <summary>Occurs whenever the ActualHeight or ActualWidth property of the Silverlight plugin changes.</summary>
    /// <param name="handler" type="Function" />
    /// <returns type="Number">eventId</returns>
    TypeSafety({"Function" : handler});
    return this.element.addEventListener("Resize", handler);
}
    
BrowserHost.prototype.remove_Resize = function(eventId) {
    /// <summary>Occurs whenever the ActualHeight or ActualWidth property of the Silverlight plugin changes.</summary>
    /// <param name="eventId" type="Number">eventId returned from add_BrowserHost</param>
    TypeSafety({"Number" : eventId});
    this.element.removeEventListener("Resize", eventId);
}

BrowserHost.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

RepeatBehavior = function(RepeatBehaviorXamlElement) 
{
        /// <summary>Describes how a Timeline repeats its simple duration.</summary>
        /// <param name="RepeatBehaviorXamlElement">Non strongly typed Xaml Element</param>
        this.element = RepeatBehaviorXamlElement;
}
RepeatBehavior.prototype.get_forever = function()
{
    /// <summary></summary>
    /// <returns type="RepeatBehavior" integer="False" />   
    return Convert.ToRepeatBehavior(this.element.forever);
}

RepeatBehavior.prototype.get_hasCount = function()
{
    /// <summary></summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.hasCount);
}

RepeatBehavior.prototype.get_hasDuration = function()
{
    /// <summary></summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.hasDuration);
}

RepeatBehavior.prototype.get_count = function()
{
    /// <summary>Gets the number of items contained in the collection.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.count);
}

RepeatBehavior.prototype.get_duration = function()
{
    /// <summary>Gets the natural duration of the media.</summary>
    /// <returns type="String" integer="False" />   
    return (this.element.duration);
}

RepeatBehavior.prototype.equals = function(value)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="value" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":value});
    return (this.element.equals(value));
}

RepeatBehavior.prototype.equals = function(repeatBehavior)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="repeatBehavior" type="RepeatBehavior" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"RepeatBehavior":repeatBehavior});
    return (this.element.equals(repeatBehavior.element));
}

RepeatBehavior.prototype.equals = function(repeatBehavior1, repeatBehavior2)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="repeatBehavior1" type="RepeatBehavior" integer="False" >The object to compare to the calling object.</param>   
    /// <param name="repeatBehavior2" type="RepeatBehavior" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"RepeatBehavior":repeatBehavior1, "RepeatBehavior":repeatBehavior2});
    return (this.element.equals(repeatBehavior1.element, repeatBehavior2.element));
}

RepeatBehavior.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

RepeatBehavior.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

RepeatBehavior.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

RepeatBehavior.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

KeyTime = function(KeyTimeXamlElement) 
{
        /// <summary>During the relative course of an animation, a KeyTime instance specifies the precise timing when a particular key frame should take place.</summary>
        /// <param name="KeyTimeXamlElement">Non strongly typed Xaml Element</param>
        this.element = KeyTimeXamlElement;
}
KeyTime.prototype.get_uniform = function()
{
    /// <summary></summary>
    /// <returns type="KeyTime" integer="False" />   
    return Convert.ToKeyTime(this.element.uniform);
}

KeyTime.prototype.get_paced = function()
{
    /// <summary></summary>
    /// <returns type="KeyTime" integer="False" />   
    return Convert.ToKeyTime(this.element.paced);
}

KeyTime.prototype.get_timeSpan = function()
{
    /// <summary></summary>
    /// <returns type="String" integer="False" />   
    return (this.element.timeSpan);
}

KeyTime.prototype.get_percent = function()
{
    /// <summary></summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.percent);
}

KeyTime.prototype.get_type = function()
{
    /// <summary>Gets the ErrorType of the error associated with the event.</summary>
    /// <returns type="KeyTimeType" integer="False" />   
    return Convert.ToKeyTimeType(this.element.type);
}

KeyTime.prototype.fromPercent = function(percent)
{
     /// <summary></summary>
    /// <param name="percent" type="Double" integer="False" ></param>   
    /// <returns type="KeyTime" integer="False" />   
    TypeSafety({"Double":percent});
    return Convert.ToKeyTime(this.element.fromPercent(percent));
}

KeyTime.prototype.fromTimeSpan = function(timeSpan)
{
     /// <summary></summary>
    /// <param name="timeSpan" type="String" integer="False" ></param>   
    /// <returns type="KeyTime" integer="False" />   
    TypeSafety({"String":timeSpan});
    return Convert.ToKeyTime(this.element.fromTimeSpan(timeSpan));
}

KeyTime.prototype.equals = function(keyTime1, keyTime2)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="keyTime1" type="KeyTime" integer="False" >The object to compare to the calling object.</param>   
    /// <param name="keyTime2" type="KeyTime" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"KeyTime":keyTime1, "KeyTime":keyTime2});
    return (this.element.equals(keyTime1.element, keyTime2.element));
}

KeyTime.prototype.equals = function(value)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="value" type="KeyTime" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"KeyTime":value});
    return (this.element.equals(value.element));
}

KeyTime.prototype.equals = function(value)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="value" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":value});
    return (this.element.equals(value));
}

KeyTime.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

KeyTime.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

KeyTime.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

KeyTime.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

KeyTimeType = function(KeyTimeTypeXamlElement) 
{
        /// <summary></summary>
        /// <param name="KeyTimeTypeXamlElement">Non strongly typed Xaml Element</param>
        this.element = KeyTimeTypeXamlElement;
}
KeyTimeType.get_Uniform = function()
{
    /// <returns type="KeyTimeType" />
    return Convert.ToKeyTimeType("Uniform");
}

KeyTimeType.is_Uniform = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="KeyTimeType" />
    return valueToCompare.element == "Uniform";
}

KeyTimeType.get_Paced = function()
{
    /// <returns type="KeyTimeType" />
    return Convert.ToKeyTimeType("Paced");
}

KeyTimeType.is_Paced = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="KeyTimeType" />
    return valueToCompare.element == "Paced";
}

KeyTimeType.get_Percent = function()
{
    /// <returns type="KeyTimeType" />
    return Convert.ToKeyTimeType("Percent");
}

KeyTimeType.is_Percent = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="KeyTimeType" />
    return valueToCompare.element == "Percent";
}

KeyTimeType.get_TimeSpan = function()
{
    /// <returns type="KeyTimeType" />
    return Convert.ToKeyTimeType("TimeSpan");
}

KeyTimeType.is_TimeSpan = function(valueToCompare)
{
    /// <returns type="bool" />
    /// <param name="valueToCompare" type="KeyTimeType" />
    return valueToCompare.element == "TimeSpan";
}

KeyTimeType.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

KeyTimeType.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

KeyTimeType.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

KeyTimeType.prototype.toString = function(format, provider)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format, "IFormatProvider":provider});
    return (this.element.toString(format, provider));
}

KeyTimeType.prototype.compareTo = function(target)
{
     /// <summary></summary>
    /// <param name="target" type="Object" integer="False" ></param>   
    /// <returns type="Number" integer="True" />   
    TypeSafety({"Object":target});
    return (this.element.compareTo(target));
}

KeyTimeType.prototype.toString = function(format)
{
     /// <summary></summary>
    /// <param name="format" type="String" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"String":format});
    return (this.element.toString(format));
}

KeyTimeType.prototype.toString = function(provider)
{
     /// <summary></summary>
    /// <param name="provider" type="IFormatProvider" integer="False" ></param>   
    /// <returns type="String" integer="False" />   
    TypeSafety({"IFormatProvider":provider});
    return (this.element.toString(provider));
}

KeyTimeType.prototype.getTypeCode = function()
{
     /// <summary></summary>
    /// <returns type="TypeCode" integer="False" />   
    TypeSafety({});
    return (this.element.getTypeCode());
}

KeyTimeType.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

KeyTimeType.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

Matrix = function(MatrixXamlElement) 
{
        /// <summary>Represents a 3x3 affine transformation matrix used for transformations in 2-D space.</summary>
        /// <param name="MatrixXamlElement">Non strongly typed Xaml Element</param>
        this.element = MatrixXamlElement;
}
Matrix.prototype.get_identity = function()
{
    /// <summary></summary>
    /// <returns type="Matrix" integer="False" />   
    return Convert.ToMatrix(this.element.identity);
}

Matrix.prototype.get_isIdentity = function()
{
    /// <summary></summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.isIdentity);
}

Matrix.prototype.set_m11 = function(value)
{
    /// <summary>Gets or sets the value of the first row and first column of this Matrix.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.m11 = value;
}

Matrix.prototype.get_m11 = function()
{
    /// <summary>Gets or sets the value of the first row and first column of this Matrix.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.m11);
}

Matrix.prototype.set_m12 = function(value)
{
    /// <summary>Gets or sets the value of the first row and second column of this Matrix.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.m12 = value;
}

Matrix.prototype.get_m12 = function()
{
    /// <summary>Gets or sets the value of the first row and second column of this Matrix.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.m12);
}

Matrix.prototype.set_m21 = function(value)
{
    /// <summary>Gets or sets the value of the second row and first column of this Matrix.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.m21 = value;
}

Matrix.prototype.get_m21 = function()
{
    /// <summary>Gets or sets the value of the second row and first column of this Matrix.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.m21);
}

Matrix.prototype.set_m22 = function(value)
{
    /// <summary>Gets or sets the value of the second row and second column of this Matrix.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.m22 = value;
}

Matrix.prototype.get_m22 = function()
{
    /// <summary>Gets or sets the value of the second row and second column of this Matrix.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.m22);
}

Matrix.prototype.set_offsetX = function(value)
{
    /// <summary>Gets or sets the value of the third row and first column of this Matrix.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.offsetX = value;
}

Matrix.prototype.get_offsetX = function()
{
    /// <summary>Gets or sets the value of the third row and first column of this Matrix.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.offsetX);
}

Matrix.prototype.set_offsetY = function(value)
{
    /// <summary>Gets or sets the value of the third row and second column of this Matrix.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.offsetY = value;
}

Matrix.prototype.get_offsetY = function()
{
    /// <summary>Gets or sets the value of the third row and second column of this Matrix.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.offsetY);
}

Matrix.prototype.setIdentity = function()
{
     /// <summary></summary>
    TypeSafety({});
    return (this.element.setIdentity());
}

Matrix.prototype.equals = function(matrix1, matrix2)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="matrix1" type="Matrix" integer="False" >The object to compare to the calling object.</param>   
    /// <param name="matrix2" type="Matrix" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Matrix":matrix1, "Matrix":matrix2});
    return (this.element.equals(matrix1.element, matrix2.element));
}

Matrix.prototype.equals = function(o)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="o" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":o});
    return (this.element.equals(o));
}

Matrix.prototype.equals = function(value)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="value" type="Matrix" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Matrix":value});
    return (this.element.equals(value.element));
}

Matrix.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

Matrix.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

Matrix.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

Matrix.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

Rect = function(RectXamlElement) 
{
        /// <summary>A Rect object stores the upper-left corner, width, and height of a rectangle.</summary>
        /// <param name="RectXamlElement">Non strongly typed Xaml Element</param>
        this.element = RectXamlElement;
}
Rect.prototype.get_empty = function()
{
    /// <summary></summary>
    /// <returns type="Rect" integer="False" />   
    return Convert.ToRect(this.element.empty);
}

Rect.prototype.get_isEmpty = function()
{
    /// <summary></summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.isEmpty);
}

Rect.prototype.set_location = function(value)
{
    /// <summary></summary>
    /// <param name="value" type="Point" integer="False" />
    TypeSafety({"Point" : value});   
    this.element.location = value.element;
}

Rect.prototype.get_location = function()
{
    /// <summary></summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.location);
}

Rect.prototype.set_size = function(value)
{
    /// <summary>Gets or sets the x- and y-radius of the arc as a Size structure.</summary>
    /// <param name="value" type="Size" integer="False" />
    TypeSafety({"Size" : value});   
    this.element.size = value.element;
}

Rect.prototype.get_size = function()
{
    /// <summary>Gets or sets the x- and y-radius of the arc as a Size structure.</summary>
    /// <returns type="Size" integer="False" />   
    return Convert.ToSize(this.element.size);
}

Rect.prototype.set_x = function(value)
{
    /// <summary>Gets or sets the x-radius value of the EllipseGeometry.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.x = value;
}

Rect.prototype.get_x = function()
{
    /// <summary>Gets or sets the x-radius value of the EllipseGeometry.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.x);
}

Rect.prototype.set_y = function(value)
{
    /// <summary>Gets or sets the total amount by which the animation changes its starting value.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.y = value;
}

Rect.prototype.get_y = function()
{
    /// <summary>Gets or sets the total amount by which the animation changes its starting value.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.y);
}

Rect.prototype.set_width = function(value)
{
    /// <summary>The width of the associated stroke.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.width = value;
}

Rect.prototype.get_width = function()
{
    /// <summary>The width of the associated stroke.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.width);
}

Rect.prototype.set_height = function(value)
{
    /// <summary>The height of the associated stroke.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.height = value;
}

Rect.prototype.get_height = function()
{
    /// <summary>The height of the associated stroke.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.height);
}

Rect.prototype.get_left = function()
{
    /// <summary>Gets or sets a value that represents the distance between the left side of an element and the left side of its parent Canvas.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.left);
}

Rect.prototype.get_top = function()
{
    /// <summary>Gets or sets a value that represents the distance between the top of an element and the top of its parent Canvas.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.top);
}

Rect.prototype.get_right = function()
{
    /// <summary></summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.right);
}

Rect.prototype.get_bottom = function()
{
    /// <summary></summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.bottom);
}

Rect.prototype.get_topLeft = function()
{
    /// <summary></summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.topLeft);
}

Rect.prototype.get_topRight = function()
{
    /// <summary></summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.topRight);
}

Rect.prototype.get_bottomLeft = function()
{
    /// <summary></summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.bottomLeft);
}

Rect.prototype.get_bottomRight = function()
{
    /// <summary></summary>
    /// <returns type="Point" integer="False" />   
    return Convert.ToPoint(this.element.bottomRight);
}

Rect.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

Rect.prototype.contains = function(point)
{
     /// <summary></summary>
    /// <param name="point" type="Point" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Point":point});
    return (this.element.contains(point.element));
}

Rect.prototype.contains = function(x, y)
{
     /// <summary></summary>
    /// <param name="x" type="Double" integer="False" ></param>   
    /// <param name="y" type="Double" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Double":x, "Double":y});
    return (this.element.contains(x, y));
}

Rect.prototype.contains = function(rect)
{
     /// <summary></summary>
    /// <param name="rect" type="Rect" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Rect":rect});
    return (this.element.contains(rect.element));
}

Rect.prototype.intersectsWith = function(rect)
{
     /// <summary></summary>
    /// <param name="rect" type="Rect" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Rect":rect});
    return (this.element.intersectsWith(rect.element));
}

Rect.prototype.intersect = function(rect)
{
     /// <summary></summary>
    /// <param name="rect" type="Rect" integer="False" ></param>   
    TypeSafety({"Rect":rect});
    return (this.element.intersect(rect.element));
}

Rect.prototype.intersect = function(rect1, rect2)
{
     /// <summary></summary>
    /// <param name="rect1" type="Rect" integer="False" ></param>   
    /// <param name="rect2" type="Rect" integer="False" ></param>   
    /// <returns type="Rect" integer="False" />   
    TypeSafety({"Rect":rect1, "Rect":rect2});
    return Convert.ToRect(this.element.intersect(rect1.element, rect2.element));
}

Rect.prototype.union = function(rect)
{
     /// <summary></summary>
    /// <param name="rect" type="Rect" integer="False" ></param>   
    TypeSafety({"Rect":rect});
    return (this.element.union(rect.element));
}

Rect.prototype.union = function(rect1, rect2)
{
     /// <summary></summary>
    /// <param name="rect1" type="Rect" integer="False" ></param>   
    /// <param name="rect2" type="Rect" integer="False" ></param>   
    /// <returns type="Rect" integer="False" />   
    TypeSafety({"Rect":rect1, "Rect":rect2});
    return Convert.ToRect(this.element.union(rect1.element, rect2.element));
}

Rect.prototype.union = function(point)
{
     /// <summary></summary>
    /// <param name="point" type="Point" integer="False" ></param>   
    TypeSafety({"Point":point});
    return (this.element.union(point.element));
}

Rect.prototype.union = function(rect, point)
{
     /// <summary></summary>
    /// <param name="rect" type="Rect" integer="False" ></param>   
    /// <param name="point" type="Point" integer="False" ></param>   
    /// <returns type="Rect" integer="False" />   
    TypeSafety({"Rect":rect, "Point":point});
    return Convert.ToRect(this.element.union(rect.element, point.element));
}

Rect.prototype.offset = function(offsetX, offsetY)
{
     /// <summary></summary>
    /// <param name="offsetX" type="Double" integer="False" ></param>   
    /// <param name="offsetY" type="Double" integer="False" ></param>   
    TypeSafety({"Double":offsetX, "Double":offsetY});
    return (this.element.offset(offsetX, offsetY));
}

Rect.prototype.offset = function(rect, offsetX, offsetY)
{
     /// <summary></summary>
    /// <param name="rect" type="Rect" integer="False" ></param>   
    /// <param name="offsetX" type="Double" integer="False" ></param>   
    /// <param name="offsetY" type="Double" integer="False" ></param>   
    /// <returns type="Rect" integer="False" />   
    TypeSafety({"Rect":rect, "Double":offsetX, "Double":offsetY});
    return Convert.ToRect(this.element.offset(rect.element, offsetX, offsetY));
}

Rect.prototype.inflate = function(size)
{
     /// <summary></summary>
    /// <param name="size" type="Size" integer="False" ></param>   
    TypeSafety({"Size":size});
    return (this.element.inflate(size.element));
}

Rect.prototype.inflate = function(width, height)
{
     /// <summary></summary>
    /// <param name="width" type="Double" integer="False" ></param>   
    /// <param name="height" type="Double" integer="False" ></param>   
    TypeSafety({"Double":width, "Double":height});
    return (this.element.inflate(width, height));
}

Rect.prototype.inflate = function(rect, size)
{
     /// <summary></summary>
    /// <param name="rect" type="Rect" integer="False" ></param>   
    /// <param name="size" type="Size" integer="False" ></param>   
    /// <returns type="Rect" integer="False" />   
    TypeSafety({"Rect":rect, "Size":size});
    return Convert.ToRect(this.element.inflate(rect.element, size.element));
}

Rect.prototype.inflate = function(rect, width, height)
{
     /// <summary></summary>
    /// <param name="rect" type="Rect" integer="False" ></param>   
    /// <param name="width" type="Double" integer="False" ></param>   
    /// <param name="height" type="Double" integer="False" ></param>   
    /// <returns type="Rect" integer="False" />   
    TypeSafety({"Rect":rect, "Double":width, "Double":height});
    return Convert.ToRect(this.element.inflate(rect.element, width, height));
}

Rect.prototype.scale = function(scaleX, scaleY)
{
     /// <summary></summary>
    /// <param name="scaleX" type="Double" integer="False" ></param>   
    /// <param name="scaleY" type="Double" integer="False" ></param>   
    TypeSafety({"Double":scaleX, "Double":scaleY});
    return (this.element.scale(scaleX, scaleY));
}

Rect.prototype.equals = function(rect1, rect2)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="rect1" type="Rect" integer="False" >The object to compare to the calling object.</param>   
    /// <param name="rect2" type="Rect" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Rect":rect1, "Rect":rect2});
    return (this.element.equals(rect1.element, rect2.element));
}

Rect.prototype.equals = function(o)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="o" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":o});
    return (this.element.equals(o));
}

Rect.prototype.equals = function(value)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="value" type="Rect" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Rect":value});
    return (this.element.equals(value.element));
}

Rect.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

Rect.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

Rect.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

Point = function(PointXamlElement) 
{
        /// <summary>Represents an ordered pair of integer x- and y-coordinates that defines a point in a two-dimensional plane.</summary>
        /// <param name="PointXamlElement">Non strongly typed Xaml Element</param>
        this.element = PointXamlElement;
}
Point.prototype.set_x = function(value)
{
    /// <summary>Gets or sets the x-radius value of the EllipseGeometry.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.x = value;
}

Point.prototype.get_x = function()
{
    /// <summary>Gets or sets the x-radius value of the EllipseGeometry.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.x);
}

Point.prototype.set_y = function(value)
{
    /// <summary>Gets or sets the total amount by which the animation changes its starting value.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.y = value;
}

Point.prototype.get_y = function()
{
    /// <summary>Gets or sets the total amount by which the animation changes its starting value.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.y);
}

Point.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

Point.prototype.equals = function(point1, point2)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="point1" type="Point" integer="False" >The object to compare to the calling object.</param>   
    /// <param name="point2" type="Point" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Point":point1, "Point":point2});
    return (this.element.equals(point1.element, point2.element));
}

Point.prototype.equals = function(o)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="o" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":o});
    return (this.element.equals(o));
}

Point.prototype.equals = function(value)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="value" type="Point" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Point":value});
    return (this.element.equals(value.element));
}

Point.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

Point.prototype.offset = function(offsetX, offsetY)
{
     /// <summary></summary>
    /// <param name="offsetX" type="Double" integer="False" ></param>   
    /// <param name="offsetY" type="Double" integer="False" ></param>   
    TypeSafety({"Double":offsetX, "Double":offsetY});
    return (this.element.offset(offsetX, offsetY));
}

Point.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

Point.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

Size = function(SizeXamlElement) 
{
        /// <summary>Implements a structure that is used to describe the Size of an object.</summary>
        /// <param name="SizeXamlElement">Non strongly typed Xaml Element</param>
        this.element = SizeXamlElement;
}
Size.prototype.get_empty = function()
{
    /// <summary></summary>
    /// <returns type="Size" integer="False" />   
    return Convert.ToSize(this.element.empty);
}

Size.prototype.get_isEmpty = function()
{
    /// <summary></summary>
    /// <returns type="Boolean" integer="False" />   
    return (this.element.isEmpty);
}

Size.prototype.set_width = function(value)
{
    /// <summary>The width of the associated stroke.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.width = value;
}

Size.prototype.get_width = function()
{
    /// <summary>The width of the associated stroke.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.width);
}

Size.prototype.set_height = function(value)
{
    /// <summary>The height of the associated stroke.</summary>
    /// <param name="value" type="Double" integer="False" />
    TypeSafety({"Double" : value});   
    this.element.height = value;
}

Size.prototype.get_height = function()
{
    /// <summary>The height of the associated stroke.</summary>
    /// <returns type="Double" integer="False" />   
    return (this.element.height);
}

Size.prototype.equals = function(size1, size2)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="size1" type="Size" integer="False" >The object to compare to the calling object.</param>   
    /// <param name="size2" type="Size" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Size":size1, "Size":size2});
    return (this.element.equals(size1.element, size2.element));
}

Size.prototype.equals = function(o)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="o" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":o});
    return (this.element.equals(o));
}

Size.prototype.equals = function(value)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="value" type="Size" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Size":value});
    return (this.element.equals(value.element));
}

Size.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

Size.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

Size.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

Size.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

Color = function(ColorXamlElement) 
{
        /// <summary>Describes a color in terms of alpha, red, green, and blue channels.</summary>
        /// <param name="ColorXamlElement">Non strongly typed Xaml Element</param>
        this.element = ColorXamlElement;
}
Color.prototype.set_a = function(value)
{
    /// <summary>Gets or sets a Geometry that specifies the shape to be drawn.</summary>
    /// <param name="value" type="Byte" integer="False" />
    TypeSafety({"Byte" : value});   
    this.element.a = value;
}

Color.prototype.get_a = function()
{
    /// <summary>Gets or sets a Geometry that specifies the shape to be drawn.</summary>
    /// <returns type="Byte" integer="False" />   
    return (this.element.a);
}

Color.prototype.set_r = function(value)
{
    /// <summary>The color of the associated stroke.</summary>
    /// <param name="value" type="Byte" integer="False" />
    TypeSafety({"Byte" : value});   
    this.element.r = value;
}

Color.prototype.get_r = function()
{
    /// <summary>The color of the associated stroke.</summary>
    /// <returns type="Byte" integer="False" />   
    return (this.element.r);
}

Color.prototype.set_g = function(value)
{
    /// <summary>Gets or sets the String that represents the Unicode string for the Glyphs object.</summary>
    /// <param name="value" type="Byte" integer="False" />
    TypeSafety({"Byte" : value});   
    this.element.g = value;
}

Color.prototype.get_g = function()
{
    /// <summary>Gets or sets the String that represents the Unicode string for the Glyphs object.</summary>
    /// <returns type="Byte" integer="False" />   
    return (this.element.g);
}

Color.prototype.set_b = function(value)
{
    /// <summary></summary>
    /// <param name="value" type="Byte" integer="False" />
    TypeSafety({"Byte" : value});   
    this.element.b = value;
}

Color.prototype.get_b = function()
{
    /// <summary></summary>
    /// <returns type="Byte" integer="False" />   
    return (this.element.b);
}

Color.prototype.set_scA = function(value)
{
    /// <summary></summary>
    /// <param name="value" type="Single" integer="False" />
    TypeSafety({"Single" : value});   
    this.element.scA = value;
}

Color.prototype.get_scA = function()
{
    /// <summary></summary>
    /// <returns type="Single" integer="False" />   
    return (this.element.scA);
}

Color.prototype.set_scR = function(value)
{
    /// <summary></summary>
    /// <param name="value" type="Single" integer="False" />
    TypeSafety({"Single" : value});   
    this.element.scR = value;
}

Color.prototype.get_scR = function()
{
    /// <summary></summary>
    /// <returns type="Single" integer="False" />   
    return (this.element.scR);
}

Color.prototype.set_scG = function(value)
{
    /// <summary></summary>
    /// <param name="value" type="Single" integer="False" />
    TypeSafety({"Single" : value});   
    this.element.scG = value;
}

Color.prototype.get_scG = function()
{
    /// <summary></summary>
    /// <returns type="Single" integer="False" />   
    return (this.element.scG);
}

Color.prototype.set_scB = function(value)
{
    /// <summary></summary>
    /// <param name="value" type="Single" integer="False" />
    TypeSafety({"Single" : value});   
    this.element.scB = value;
}

Color.prototype.get_scB = function()
{
    /// <summary></summary>
    /// <returns type="Single" integer="False" />   
    return (this.element.scB);
}

Color.prototype.fromScRgb = function(a, r, g, b)
{
     /// <summary></summary>
    /// <param name="a" type="Single" integer="False" ></param>   
    /// <param name="r" type="Single" integer="False" ></param>   
    /// <param name="g" type="Single" integer="False" ></param>   
    /// <param name="b" type="Single" integer="False" ></param>   
    /// <returns type="Color" integer="False" />   
    TypeSafety({"Single":a, "Single":r, "Single":g, "Single":b});
    return Convert.ToColor(this.element.fromScRgb(a, r, g, b));
}

Color.prototype.fromArgb = function(a, r, g, b)
{
     /// <summary></summary>
    /// <param name="a" type="Byte" integer="False" ></param>   
    /// <param name="r" type="Byte" integer="False" ></param>   
    /// <param name="g" type="Byte" integer="False" ></param>   
    /// <param name="b" type="Byte" integer="False" ></param>   
    /// <returns type="Color" integer="False" />   
    TypeSafety({"Byte":a, "Byte":r, "Byte":g, "Byte":b});
    return Convert.ToColor(this.element.fromArgb(a, r, g, b));
}

Color.prototype.fromRgb = function(r, g, b)
{
     /// <summary></summary>
    /// <param name="r" type="Byte" integer="False" ></param>   
    /// <param name="g" type="Byte" integer="False" ></param>   
    /// <param name="b" type="Byte" integer="False" ></param>   
    /// <returns type="Color" integer="False" />   
    TypeSafety({"Byte":r, "Byte":g, "Byte":b});
    return Convert.ToColor(this.element.fromRgb(r, g, b));
}

Color.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

Color.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

Color.prototype.areClose = function(color1, color2)
{
     /// <summary></summary>
    /// <param name="color1" type="Color" integer="False" ></param>   
    /// <param name="color2" type="Color" integer="False" ></param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Color":color1, "Color":color2});
    return (this.element.areClose(color1.element, color2.element));
}

Color.prototype.clamp = function()
{
     /// <summary></summary>
    TypeSafety({});
    return (this.element.clamp());
}

Color.prototype.add = function(color1, color2)
{
     /// <summary>Adds an object to the end of the collection.</summary>
    /// <param name="color1" type="Color" integer="False" >The object to add to the collection.</param>   
    /// <param name="color2" type="Color" integer="False" >The object to add to the collection.</param>   
    /// <returns type="Color" integer="False" />   
    TypeSafety({"Color":color1, "Color":color2});
    return Convert.ToColor(this.element.add(color1.element, color2.element));
}

Color.prototype.subtract = function(color1, color2)
{
     /// <summary></summary>
    /// <param name="color1" type="Color" integer="False" ></param>   
    /// <param name="color2" type="Color" integer="False" ></param>   
    /// <returns type="Color" integer="False" />   
    TypeSafety({"Color":color1, "Color":color2});
    return Convert.ToColor(this.element.subtract(color1.element, color2.element));
}

Color.prototype.multiply = function(color, coefficient)
{
     /// <summary></summary>
    /// <param name="color" type="Color" integer="False" ></param>   
    /// <param name="coefficient" type="Single" integer="False" ></param>   
    /// <returns type="Color" integer="False" />   
    TypeSafety({"Color":color, "Single":coefficient});
    return Convert.ToColor(this.element.multiply(color.element, coefficient));
}

Color.prototype.equals = function(color1, color2)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="color1" type="Color" integer="False" >The object to compare to the calling object.</param>   
    /// <param name="color2" type="Color" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Color":color1, "Color":color2});
    return (this.element.equals(color1.element, color2.element));
}

Color.prototype.equals = function(color)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="color" type="Color" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Color":color});
    return (this.element.equals(color.element));
}

Color.prototype.equals = function(o)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="o" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":o});
    return (this.element.equals(o));
}

Color.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

Color.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

Colors = function(ColorsXamlElement) 
{
        /// <summary></summary>
        /// <param name="ColorsXamlElement">Non strongly typed Xaml Element</param>
        this.element = ColorsXamlElement;
}
Colors.prototype.get_black = function()
{
    /// <summary></summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.black);
}

Colors.prototype.get_blue = function()
{
    /// <summary></summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.blue);
}

Colors.prototype.get_brown = function()
{
    /// <summary></summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.brown);
}

Colors.prototype.get_cyan = function()
{
    /// <summary></summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.cyan);
}

Colors.prototype.get_darkGray = function()
{
    /// <summary></summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.darkGray);
}

Colors.prototype.get_gray = function()
{
    /// <summary></summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.gray);
}

Colors.prototype.get_green = function()
{
    /// <summary></summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.green);
}

Colors.prototype.get_lightGray = function()
{
    /// <summary></summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.lightGray);
}

Colors.prototype.get_magenta = function()
{
    /// <summary></summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.magenta);
}

Colors.prototype.get_orange = function()
{
    /// <summary></summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.orange);
}

Colors.prototype.get_purple = function()
{
    /// <summary></summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.purple);
}

Colors.prototype.get_red = function()
{
    /// <summary></summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.red);
}

Colors.prototype.get_transparent = function()
{
    /// <summary></summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.transparent);
}

Colors.prototype.get_white = function()
{
    /// <summary></summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.white);
}

Colors.prototype.get_yellow = function()
{
    /// <summary></summary>
    /// <returns type="Color" integer="False" />   
    return Convert.ToColor(this.element.yellow);
}

Colors.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

Colors.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

Colors.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

Colors.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

Colors.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

XamlReader = function(XamlReaderXamlElement) 
{
        /// <summary></summary>
        /// <param name="XamlReaderXamlElement">Non strongly typed Xaml Element</param>
        this.element = XamlReaderXamlElement;
}
XamlReader.prototype.load = function(xaml)
{
     /// <summary></summary>
    /// <param name="xaml" type="String" integer="False" ></param>   
    /// <returns type="DependencyObject" integer="False" />   
    TypeSafety({"String":xaml});
    return Convert.ToDependencyObject(this.element.load(xaml));
}

XamlReader.prototype.load = function(xaml, createNamescope)
{
     /// <summary></summary>
    /// <param name="xaml" type="String" integer="False" ></param>   
    /// <param name="createNamescope" type="Boolean" integer="False" ></param>   
    /// <returns type="DependencyObject" integer="False" />   
    TypeSafety({"String":xaml, "Boolean":createNamescope});
    return Convert.ToDependencyObject(this.element.load(xaml, createNamescope));
}

XamlReader.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

XamlReader.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

XamlReader.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

XamlReader.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

XamlReader.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

DependencyProperty = function(DependencyPropertyXamlElement) 
{
        /// <summary></summary>
        /// <param name="DependencyPropertyXamlElement">Non strongly typed Xaml Element</param>
        this.element = DependencyPropertyXamlElement;
}
DependencyProperty.prototype.getType = function()
{
     /// <summary></summary>
    /// <returns type="Type" integer="False" />   
    TypeSafety({});
    return (this.element.getType());
}

DependencyProperty.prototype.toString = function()
{
     /// <summary></summary>
    /// <returns type="String" integer="False" />   
    TypeSafety({});
    return (this.element.toString());
}

DependencyProperty.prototype.equals = function(obj)
{
     /// <summary>Checks for equality of an object to the current object.</summary>
    /// <param name="obj" type="Object" integer="False" >The object to compare to the calling object.</param>   
    /// <returns type="Boolean" integer="False" />   
    TypeSafety({"Object":obj});
    return (this.element.equals(obj));
}

DependencyProperty.prototype.getHashCode = function()
{
     /// <summary></summary>
    /// <returns type="Number" integer="True" />   
    TypeSafety({});
    return (this.element.getHashCode());
}

DependencyProperty.prototype.get_innerElement = function()
{
    /// <returns>Non intellisensed XAML object</returns>
    return this.element; 
}

